C#复习(与C++对比)

笔记
字数统计: 13k   |   阅读时长≈ 49 分钟

花一天半看了一下C#基本语法，先做个笔记，供后期参考。

输入输出

1
2
3
4
5
Console.Read();					// 从控制台窗口读取一个字符，返回int
Console.ReadLine();				// 从控制台窗口读取一行文本，返回string值
Console.ReadKey();				// 监听键盘事件，可以理解为按任意键执行
Console.Write();				// 将制定的值写入控制台窗口
Console.WriteLine();			// 将制定的值写入控制台窗口，但在输出结果的最后添加一个换行符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
int i = 5, j = 10;
Console.WriteLine("{0} plus {1} equals {2}", i, j, i + j);
Console.WriteLine($"{i} plus {j} equals {i + j}");

int first = 940, second =89;
//为值指定宽度，调整文本在该宽度中的位置：正值表示右对齐，负值表示左对齐
//格式为{n,w}:n是参数索引，w是宽度值
Console.WriteLine(" {0,4}\n+{1,4}\n-----\n {2,4}", first, second, first + second);
Console.WriteLine();

decimal one = 912.329M, two = 88.433M;
//添加格式字符串及一个可选的精度值
Console.WriteLine(" {0,9:C2}\n+{1,9:C2}\n-----------\n {2,9:C2}", one, two, one + two);
Console.WriteLine();

double d = 08.987;
//使用占位符来替代格式字符串
//如果占位符（#）的位置上没有字符，则忽略该符号；
//如果占位符（0）的位置上有一个字符，就用这个字符替代0，否则显示0
Console.WriteLine("{0:#0.00}", d);

继承

C#多重继承

多重继承指的是一个类别可以同时从多于一个父类继承行为与特征的功能。与单一继承相对，单一继承指一个类别只可以继承自一个父类。

C# 不支持多重继承。但是，您可以使用接口来实现多重继承。下面的程序演示了这点：

构造函数执行顺序

建子类对象调用子类的构造函数时，会首先调用父类的无参构造函数。

派生类访问隐藏的基类成员

1
2
3
如果想要使得派生类能够完全访问被隐藏的继承成员，就可以使用基类访问表达式访问被隐藏的继承成员。基类访问表达式由关键字base后面跟一个点和成员的名称组成。例如：

Console.WriteLine("{0}",base.Field1);

依赖倒置原则

1
2
3
4
5
6
依赖倒置原则，DIP,Dependency Inverse Principle DIP的表述是：
1、高层模块不应该依赖于低层模块, 二者都应该依赖于抽象。
2、抽象不应该依赖于细节,细节应该依赖于抽象。
这里说的“依赖”是使用的意思，如果你调用了一个类的一个方法，就是依赖这个类，如果你直接调用这个类的方法，就是依赖细节，细节就是具体的类，但如果你调用的是它父类或者接口的方法，就是依赖抽象， 所以 DIP 说白了就是不要直接使用具体的子类，而是用它的父类的引用去调用子类的方法，这样就是依赖于抽象，不依赖具体。

其实简单的说，DIP 的好处就是解除耦合，用了 DIP 之后，调用者就不知道被调用的代码是什么，因为调用者拿到的是父类的引用，它不知道具体指向哪个子类的实例，更不知道要调用的方法具体是什么，所以，被调用代码被偷偷换成另一个子类之后，调用者不需要做任何修改， 这就是解耦了。

多态

​ 一个接口多个功能。

1
2
3
4
5
在子类中用 override 重写父类中用 virtual 申明的虚方法时，实例化父类调用该方法，执行时调用的是子类中重写的方法；

如果子类中用 new 覆盖父类中用 virtual 申明的虚方法时，实例化父类调用该方法，执行时调用的是父类中的虚方法；

深究其原因，为何两者不同，是因为原理不同： override是重写，即将基类的方法在派生类里直接抹去重新写，故而调用的方法就是子类方法；而new只是将基类的方法在派生类里隐藏起来，故而调用的仍旧是基类方法。

静态多态性

  • 函数重载
  • 运算符重载

动态多态性

  • 抽象类
1
2
3
4
5
C# 允许您使用关键字 abstract 创建抽象类，用于提供接口的部分类的实现。当一个派生类继承自该抽象类时，实现即完成。抽象类包含抽象方法，抽象方法可被派生类实现。派生类具有更专业的功能。
请注意，下面是有关抽象类的一些规则：
    您不能创建一个抽象类的实例。
    您不能在一个抽象类外部声明一个抽象方法。
    通过在类定义前面放置关键字 sealed，可以将类声明为密封类。当一个类被声明为 sealed 时，它不能被继承。抽象类不能被声明为 sealed。

  • 动态继承

    父类中的函数需要在继承类中实现时，可以使用虚方法。虚方法是使用关键字 virtual 声明的。

1
2
3
4
5
6
virtual和abstract都是用来修饰父类的，通过覆盖父类的定义，让子类重新定义。

 1.virtual修饰的方法必须有实现（哪怕是仅仅添加一对大括号),而abstract修饰的方法一定不能实现。
 2.virtual可以被子类重写，而abstract必须被子类重写。
 3.如果类成员被abstract修饰，则该类前必须添加abstract，因为只有抽象类才可以有抽象方法。
 4.无法创建abstract类的实例，只能被继承无法实例化。
1
2
3
4
5
6
1.虚方法必须有实现部分，抽象方法没有提供实现部分，抽象方法是一种强制派生类覆盖的方法，否则派生类将不能被实例化。
 2.抽象方法只能在抽象类中声明，虚方法不是。如果类包含抽象方法，那么该类也是抽象的，也必须声明类是抽象的。
 3.抽象方法必须在派生类中重写，这一点和接口类似，虚方法不需要再派生类中重写。
简单说，抽象方法是需要子类去实现的。虚方法是已经实现了的，可以被子类覆盖，也可以不覆盖，取决于需求。

抽象方法和虚方法都可以供派生类重写。

纯虚函数：

C#中竟然没有纯虚函数，而是通过abstract(抽象类)和interface(接口)代替了！

重载和重写

1
2
3
4
5
6
7
8
9
10
1、重载(overload): 在同一个作用域(一般指一个类)的两个或多个方法函数名相同，参数列表不同的方法叫做重载，它们有三个特点(俗称两必须一可以):
 方法名必须相同
 参数列表必须不相同
 返回值类型可以不相同
 
2、重写(override):子类中为满足自己的需要来重复定义某个方法的不同实现，需要用 override 关键字，被重写的方法必须是虚方法，用的是 virtual 关键字。它的特点是(三个相同):

相同的方法名
相同的参数列表
相同的返回值

虚方法和抽象方法的区别是：因为抽象类无法实例化，所以抽象方法没有办法被调用，也就是说抽象方法永远不可能被实现。

隐藏方法：

在派生类中定义的和基类中的某个方法同名的方法，使用 new 关键字定义。

  • （1）隐藏方法不但可以隐藏基类中的虚方法，而且也可以隐藏基类中的非虚方法。
  • （2）隐藏方法中父类的实例调用父类的方法，子类的实例调用子类的方法。
  • （3）和上一条对比：重写方法中子类的变量调用子类重写的方法，父类的变量要看这个父类引用的是子类的实例还是本身的实例，如果引用的是父类的实例那么调用基类的方法，如果引用的是派生类的实例则调用派生类的方法。

C# 接口（Interface）

接口定义了属性、方法和事件，这些都是接口的成员。接口只包含了成员的声明。成员的定义是派生类的责任。接口提供了派生类应遵循的标准结构。

接口使用 interface 关键字声明，它与类的声明类似。接口声明默认是 public 的。下面是一个接口声明的实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
using System;

interface IMyInterface
{
        // 接口成员
    void MethodToImplement();
}

class InterfaceImplementer : IMyInterface
{
    static void Main()
    {
        InterfaceImplementer iImp = new InterfaceImplementer();
        iImp.MethodToImplement();
    }

    public void MethodToImplement()
    {
        Console.WriteLine("MethodToImplement() called.");
    }
}

以上代码定义了接口 IMyInterface。通常接口命令以 I 字母开头，这个接口只有一个方法 MethodToImplement()。InterfaceImplementer 类实现了 IMyInterface 接口，接口的实现与类的继承语法格式类似：

如果一个接口继承其他接口，那么实现类或结构就需要实现所有接口的成员。

接口的继承

1
2
3
4
5
6
接口的定义是指定一组函数成员而不实现成员的引用类型，其它类型和接口可以继承接口。定义还是很好理解的，但是没有反映特点，接口主要有以下特点：

 (1)通过接口可以实现多重继承，C# 接口的成员不能有 public、protected、internal、private 等修饰符。原因很简单，接口里面的方法都需要由外面接口实现去实现方法体，那么其修饰符必然是 public。C# 接口中的成员默认是 public 的，java 中是可以加 public 的。
 (2)接口成员不能有 new、static、abstract、override、virtual 修饰符。有一点要注意，当一个接口实现一个接口，这2个接口中有相同的方法时，可用 new 关键字隐藏父接口中的方法。
 (3)接口中只包含成员的签名，接口没有构造函数，所以不能直接使用 new 对接口进行实例化。接口中只能包含方法、属性、事件和索引的组合。接口一旦被实现，实现类必须实现接口中的所有成员，除非实现类本身是抽象类。
 (4)C# 是单继承，接口是解决 C# 里面类可以同时继承多个基类的问题。

接口和抽象类的区别

1
2
3
4
5
6
7
8
9
10
11
12
13
14
接口用于规范，抽象类用于共性。抽象类是类，所以只能被单继承，但是接口却可以一次实现多个。
接口中只能声明方法，属性，事件，索引器。而抽象类中可以有方法的实现，也可以定义非静态的类变量。
抽象类可以提供某些方法的部分实现，接口不可以。抽象类的实例是它的子类给出的。接口的实例是实现接口的类给出的。
在抽象类中加入一个方法，那么它的子类就同时有了这个方法。而在接口中加入新的方法，那么实现它的类就要重新编写（这就是为什么说接口是一个类的规范了）。
接口成员被定义为公共的，但抽象类的成员也可以是私有的、受保护的、内部的或受保护的内部成员（其中受保护的内部成员只能在应用程序的代码或派生类中访问）。
此外接口不能包含字段、构造函数、析构函数、静态成员或常量。
还有一点，我们在VS中实现接口时会发现有2个选项，一个是实现接口，一个是显示实现接口。实现接口就是我们平常理解的实现接口，而显示实现接口的话，实现的方法是属于接口的，而不是属于实现类的。

 1、接口支持多继承，抽象类不能实现多继承。
 2、接口只能定义抽象规则，抽象类既可以定义规则，还可能提供已实现的成员。
 3、接口是一组行为规范，抽象类是一个不完全的类，着重族的概念。
 4、接口可以用于支持回调，抽象类不能实现回调，因为继承不支持。
 5、接口只包含方法、属性、索引器、事件的签名，但不能定义字段和包含实现的方法，抽象类可以定义字段、属性、包含有实现的方法。
 6、接口可以作用于值类型和引用类型，抽象类只能作用于引用类型。例如，Struct就可以继承接口，而不能继承类。

运算符重载

operator 关键字用于在类或结构声明中声明运算符。运算符声明可以采用下列四种形式之一：

1
2
3
4
public static result-type operator unary-operator ( op-type operand )
public static result-type operator binary-operator ( op-type operand, op-type2 operand2 )
public static implicit operator conv-type-out ( conv-type-in operand )
public static explicit operator conv-type-out ( conv-type-in operand )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
参数：

 result-type 运算符的结果类型。
 unary-operator 下列运算符之一：+ - ! ~ ++ — true false
 op-type 第一个（或唯一一个）参数的类型。
 operand 第一个（或唯一一个）参数的名称。
 binary-operator 其中一个：+ - * / % & | ^ << >> == != > < >= <=
 op-type2 第二个参数的类型。
 operand2 第二个参数的名称。
 conv-type-out 类型转换运算符的目标类型。
 conv-type-in 类型转换运算符的输入类型。
注意：

前两种形式声明了用户定义的重载内置运算符的运算符。并非所有内置运算符都可以被重载（请参见可重载的运算符）。op-type 和 op-type2 中至少有一个必须是封闭类型（即运算符所属的类型，或理解为自定义的类型）。例如，这将防止重定义整数加法运算符。

后两种形式声明了转换运算符。conv-type-in 和 conv-type-out 中正好有一个必须是封闭类型（即，转换运算符只能从它的封闭类型转换为其他某个类型，或从其他某个类型转换为它的封闭类型）。

运算符只能采用值参数，不能采用 ref 或 out 参数。

C# 要求成对重载比较运算符。如果重载了==，则也必须重载!=，否则产生编译错误。同时，比较运算符必须返回bool类型的值，这是与其他算术运算符的根本区别。

C# 不允许重载=运算符，但如果重载例如+运算符，编译器会自动使用+运算符的重载来执行+=运算符的操作。

运算符重载的其实就是函数重载。首先通过指定的运算表达式调用对应的运算符函数，然后再将运算对象转化为运算符函数的实参，接着根据实参的类型来确定需要调用的函数的重载，这个过程是由编译器完成。

任何运算符声明的前面都可以有一个可选的属性（C# 编程指南）列表。

C# 命名空间（Namespace）

类似于c++头文件

using的用法：

1. using指令：引入命名空间

这是最常见的用法，例如：

1
2
using System;
using Namespace1.SubNameSpace;

2. using static 指令：指定无需指定类型名称即可访问其静态成员的类型

1
using static System.Math;var = PI; // 直接使用System.Math.PI

3. 起别名

1
using Project = PC.MyCompany.Project;

4. using语句：将实例与代码绑定

1
2
3
4
5
using (Font font3 = new Font("Arial", 10.0f),
            font4 = new Font("Arial", 10.0f))
{
    // Use font3 and font4.
}

代码段结束时，自动调用font3和font4的Dispose方法，释放实例。

如果两个不同空间的类被简写后同名，则这个类会陷入不确定的引用状态。

例如一个 firstNameSpace.function.method() 和一个 **secondNameSpace.function.method()**，在写了 using firstNameSpace 和 using secondNameSpace 之后，简写都是 **function.method()**， 则报错 “function” 是 “firstNameSpace.function”和”secondNameSpace.function” 之间的不明确的引用。

C# 预处理器指令

在程序调试和运行上有重要的作用。比如预处理器指令可以禁止编译器编译代码的某一部分，如果计划发布两个版本的代码，即基本版本和有更多功能的企业版本，就可以使用这些预处理器指令来控制。在编译软件的基本版本时，使用预处理器指令还可以禁止编译器编译于额外功能相关的代码。另外，在编写提供调试信息的代码时，也可以使用预处理器指令进行控制。总的来说和普通的控制语句（if等）功能类似，方便在于预处理器指令包含的未执行部分是不需要编译的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define PI
using System;
namespace PreprocessorDAppl
{
   class Program
   {
      static void Main(string[] args)
      {
         #if (PI)
            Console.WriteLine("PI is defined");     //PI不存在，则这条语句不编译
         #else
            Console.WriteLine("PI is not defined"); //PI存在，则这条语句不编译
         #endif
         Console.ReadKey();
      }
   }
}

其他预处理器指令：

预处理器指令 描述
#define 它用于定义一系列成为符号的字符。
#undef 它用于取消定义符号。
#if 它用于测试符号是否为真。
#else 它用于创建复合条件指令，与 #if 一起使用。
#elif 它用于创建复合条件指令。
#endif 指定一个条件指令的结束。
#line 它可以让您修改编译器的行数以及（可选地）输出错误和警告的文件名。
#error 它允许从代码的指定位置生成一个错误。
#warning 它允许从代码的指定位置生成一级警告。
#region 它可以让您在使用 Visual Studio Code Editor 的大纲特性时，指定一个可展开或折叠的代码块。
#endregion 它标识着 #region 块的结束。

#warning 和 #error：

当编译器遇到它们时，会分别产生警告或错误。如果编译器遇到 #warning 指令，会给用户显示 #warning 指令后面的文本，之后编译继续进行。如果编译器遇到 #error 指令，就会给用户显示后面的文本，作为一条编译错误消息，然后会立即退出编译。使用这两条指令可以检查 #define 语句是不是做错了什么事，使用 #warning 语句可以提醒自己执行某个操作。

1
2
3
4
5
#if DEBUG && RELEASE  
#error "You've defined DEBUG and RELEASE simultaneously!"  
#endif  
#warning "Don't forget to remove this line before the boss tests the code!"  
Console.WriteLine("*I hate this job.*");

2. #region 和 #endregion

#region 和 #endregion 指令用于把一段代码标记为有给定名称的一个块，如下所示:

1
2
3
4
5
#region Member Field Declarations
int x;
double d;
Currency balance;
#endregion

这看起来似乎没有什么用，它不影响编译过程。这些指令的优点是它们可以被某些编辑器识别，包括 Visual Studio .NET 编辑器。这些编辑器可以使用这些指令使代码在屏幕上更好地布局。

3. #line

#line 指令可以用于改变编译器在警告和错误信息中显示的文件名和行号信息，不常用。

如果编写代码时，在把代码发送给编译器前，要使用某些软件包改变输入的代码，就可以使用这个指令，因为这意味着编译器报告的行号或文件名与文件中的行号或编辑的文件名不匹配。#line指令可以用于还原这种匹配。也可以使用语法#line default把行号还原为默认的行号：

1
2
3
4
5
#line 164 "Core.cs" // 在文件的第 164 行
// Core.cs, before the intermediate
// package mangles it.
// later on
#line default // 恢复默认行号

4. #pragma

#pragma 指令可以抑制或还原指定的编译警告。与命令行选项不同，#pragma 指令可以在类或方法级别执行，对抑制警告的内容和抑制的时间进行更精细的控制。如下：

1
2
3
4
5
6
#pragma warning disable 169    // 取消编号 169 的警告（字段未使用的警告）
public class MyClass
{
    int neverUsedField;       // 编译整个 MyClass 类时不会发出警告
}
#pragma warning restore 169   // 恢复编号 169 的警告

C# 正则表达式

.Net 框架提供了允许这种匹配的正则表达式引擎。

具体参考此网址

C# 异常处理

C# 异常处理时建立在四个关键词之上的：try、catch、finally 和 throw。

  • try：一个 try 块标识了一个将被激活的特定的异常的代码块。后跟一个或多个 catch 块。

  • catch：程序通过异常处理程序捕获异常。catch 关键字表示异常的捕获。

  • finally：finally 块用于执行给定的语句，不管异常是否被抛出都会执行。例如，如果您打开一个文件，不管是否出现异常文件都要被关闭。

  • throw：当问题出现时，程序抛出一个异常。使用 throw 关键字来完成。

C# 异常是使用类来表示的：

C# 中的异常类主要是直接或间接地派生于 System.Exception 类。System.ApplicationException 和 System.SystemException 类是派生于 System.Exception 类的异常类。

System.ApplicationException 类支持由应用程序生成的异常。所以程序员定义的异常都应派生自该类。

System.SystemException 类是所有预定义的系统异常的基类。

下表列出了一些派生自 System.SystemException 类的预定义的异常类：

异常类 描述
System.IO.IOException 处理 I/O 错误。
System.IndexOutOfRangeException 处理当方法指向超出范围的数组索引时生成的错误。
System.ArrayTypeMismatchException 处理当数组类型不匹配时生成的错误。
System.NullReferenceException 处理当依从一个空对象时生成的错误。
System.DivideByZeroException 处理当除以零时生成的错误。
System.InvalidCastException 处理在类型转换期间生成的错误。
System.OutOfMemoryException 处理空闲内存不足生成的错误。
System.StackOverflowException 处理栈溢出生成的错误。

C# 文件的输入与输出

System.IO 命名空间有各种不同的类，用于执行各种文件操作，如创建和删除文件、读取或写入文件，关闭文件等。

下表列出了一些 System.IO 命名空间中常用的非抽象类：

I/O 类 描述
BinaryReader 从二进制流读取原始数据。
BinaryWriter 以二进制格式写入原始数据。
BufferedStream 字节流的临时存储。
Directory 有助于操作目录结构。
DirectoryInfo 用于对目录执行操作。
DriveInfo 提供驱动器的信息。
File 有助于处理文件。
FileInfo 用于对文件执行操作。
FileStream 用于文件中任何位置的读写。
MemoryStream 用于随机访问存储在内存中的数据流。
Path 对路径信息执行操作。
StreamReader 用于从字节流中读取字符。
StreamWriter 用于向一个流中写入字符。
StringReader 用于读取字符串缓冲区。
StringWriter 用于写入字符串缓冲区。

FileStream 类

System.IO 命名空间中的 FileStream 类有助于文件的读写与关闭。该类派生自抽象类 Stream。

您需要创建一个 FileStream 对象来创建一个新的文件，或打开一个已有的文件。创建 FileStream 对象的语法如下：

1
2
FileStream <object_name> = new FileStream( <file_name>,
<FileMode Enumerator>, <FileAccess Enumerator>, <FileShare Enumerator>);

例如，创建一个 FileStream 对象 F 来读取名为 sample.txt 的文件：

1
FileStream F = new FileStream("sample.txt", FileMode.Open, FileAccess.Read, FileShare.Read);
参数 描述
FileMode FileMode 枚举定义了各种打开文件的方法。FileMode 枚举的成员有：Append：打开一个已有的文件，并将光标放置在文件的末尾。如果文件不存在，则创建文件。Create：创建一个新的文件。如果文件已存在，则删除旧文件，然后创建新文件。CreateNew：指定操作系统应创建一个新的文件。如果文件已存在，则抛出异常。Open：打开一个已有的文件。如果文件不存在，则抛出异常。OpenOrCreate：指定操作系统应打开一个已有的文件。如果文件不存在，则用指定的名称创建一个新的文件打开。Truncate：打开一个已有的文件，文件一旦打开，就将被截断为零字节大小。然后我们可以向文件写入全新的数据，但是保留文件的初始创建日期。如果文件不存在，则抛出异常。
FileAccess FileAccess 枚举的成员有：Read、ReadWrite 和 Write。
FileShare FileShare 枚举的成员有：Inheritable：允许文件句柄可由子进程继承。Win32 不直接支持此功能。None：谢绝共享当前文件。文件关闭前，打开该文件的任何请求（由此进程或另一进程发出的请求）都将失败。Read：允许随后打开文件读取。如果未指定此标志，则文件关闭前，任何打开该文件以进行读取的请求（由此进程或另一进程发出的请求）都将失败。但是，即使指定了此标志，仍可能需要附加权限才能够访问该文件。ReadWrite：允许随后打开文件读取或写入。如果未指定此标志，则文件关闭前，任何打开该文件以进行读取或写入的请求（由此进程或另一进程发出）都将失败。但是，即使指定了此标志，仍可能需要附加权限才能够访问该文件。Write：允许随后打开文件写入。如果未指定此标志，则文件关闭前，任何打开该文件以进行写入的请求（由此进程或另一进过程发出的请求）都将失败。但是，即使指定了此标志，仍可能需要附加权限才能够访问该文件。Delete：允许随后删除文件。

C#高级文件操作

上面的实例演示了 C# 中简单的文件操作。但是，要充分利用 C# System.IO 类的强大功能，您需要知道这些类常用的属性和方法。

在下面的章节中，我们将讨论这些类和它们执行的操作。请单击链接详细了解各个部分的知识：

主题 描述
文本文件的读写 它涉及到文本文件的读写。StreamReader 和 StreamWriter 类有助于完成文本文件的读写。
二进制文件的读写 它涉及到二进制文件的读写。BinaryReader 和 BinaryWriter 类有助于完成二进制文件的读写。
Windows 文件系统的操作 它让 C# 程序员能够浏览并定位 Windows 文件和目录。

C#特性（Attribute）

某些情况下需要给类或者方法添加一些标签信息，比如我们在调试的时候为方法注明调试事件，调试人等等信息。根据定义方式的不同，特性分为系统提供的特性以及自定义的特性。

预定义特性（Attribute）

.Net 框架提供了三种预定义特性：

  • AttributeUsage
  • Conditional
  • Obsolete

创建自定义特性（Attribute）

.Net 框架允许创建自定义特性，用于存储声明性的信息，且可在运行时被检索。该信息根据设计标准和应用程序需要，可与任何目标元素相关。

创建并使用自定义特性包含四个步骤：

  • 声明自定义特性
  • 构建自定义特性
  • 在目标程序元素上应用自定义特性
  • 通过反射访问特性

最后一个步骤包含编写一个简单的程序来读取元数据以便查找各种符号。元数据是用于描述其他数据的数据和信息。该程序应使用反射来在运行时访问特性。我们将在下一章详细讨论这点。

声明自定义特性

一个新的自定义特性应派生自 System.Attribute 类。例如：

1
2
3
4
5
6
7
8
9
// 一个自定义特性 BugFix 被赋给类及其成员
[AttributeUsage(AttributeTargets.Class |
AttributeTargets.Constructor |
AttributeTargets.Field |
AttributeTargets.Method |
AttributeTargets.Property,
AllowMultiple = true)]

public class DeBugInfo : System.Attribute

在上面的代码中，我们已经声明了一个名为 DeBugInfo 的自定义特性。

构建自定义特性

让我们构建一个名为 DeBugInfo 的自定义特性，该特性将存储调试程序获得的信息。它存储下面的信息：

  • bug 的代码编号
  • 辨认该 bug 的开发人员名字
  • 最后一次审查该代码的日期
  • 一个存储了开发人员标记的字符串消息

我们的 DeBugInfo 类将带有三个用于存储前三个信息的私有属性（property）和一个用于存储消息的公有属性（property）。所以 bug 编号、开发人员名字和审查日期将是 DeBugInfo 类的必需的定位（ positional）参数，消息将是一个可选的命名（named）参数。

每个特性必须至少有一个构造函数。必需的定位（ positional）参数应通过构造函数传递。下面的代码演示了 DeBugInfo 类：

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
// 一个自定义特性 BugFix 被赋给类及其成员
[AttributeUsage(AttributeTargets.Class |
AttributeTargets.Constructor |
AttributeTargets.Field |
AttributeTargets.Method |
AttributeTargets.Property,
AllowMultiple = true)]

public class DeBugInfo : System.Attribute
{
  private int bugNo;
  private string developer;
  private string lastReview;
  public string message;

  public DeBugInfo(int bg, string dev, string d)
  {
      this.bugNo = bg;
      this.developer = dev;
      this.lastReview = d;
  }

  public int BugNo
  {
      get
      {
          return bugNo;
      }
  }
  public string Developer
  {
      get
      {
          return developer;
      }
  }
  public string LastReview
  {
      get
      {
          return lastReview;
      }
  }
  public string Message
  {
      get
      {
          return message;
      }
      set
      {
          message = value;
      }
  }
}

应用自定义特性

通过把特性放置在紧接着它的目标之前，来应用该特性：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
[DeBugInfo(45, "Zara Ali", "12/8/2012", Message = "Return type mismatch")]
[DeBugInfo(49, "Nuha Ali", "10/10/2012", Message = "Unused variable")]
class Rectangle
{
  // 成员变量
  protected double length;
  protected double width;
  public Rectangle(double l, double w)
  {
      length = l;
      width = w;
  }
  [DeBugInfo(55, "Zara Ali", "19/10/2012",
  Message = "Return type mismatch")]
  public double GetArea()
  {
      return length * width;
  }
  [DeBugInfo(56, "Zara Ali", "19/10/2012")]
  public void Display()
  {
      Console.WriteLine("Length: {0}", length);
      Console.WriteLine("Width: {0}", width);
      Console.WriteLine("Area: {0}", GetArea());
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
C# 中利用 Conditional 定义条件方法

利用 Conditional 属性，程序员可以定义条件方法。Conditional 属性通过测试条件编译符号来确定适用的条件。当运行到一个条件方法调用时，是否执行该调用，要根据出现该调用时是否已定义了此符号来确定。如果定义了此符号，则执行该调用；否则省略该调用（包括对调用的参数的计算）。使用Conditional是封闭#if和#endif内部方法的替代方法，它更整洁，更别致、减少了出错的机会。

条件方法要受到以下限制：

条件方法必须是类声明或结构声明中的方法。如果在接口声明中的方法上指定Conditional属性，将出现编译时错误。
条件方法必须具有返回类型。
不能用override修饰符标记条件方法。但是，可以用virtual修饰符标记条件方法。此类方法的重写方法隐含为有条件的方法，而且不能用Conditional属性显式标记。
条件方法不能是接口方法的实现。否则将发生编译时错误。
如果条件方法用在“委托创建表达式”中，也会发生编译时错误
这里需要注意的是：如果创建一个没有定义任何条件的方法，那么默认只要调用就总是会执行此方法，如果你想通过条件来判断执行，那么该方法上必须至少包含一个conditional特性所定义的条件，它才会响应你定义的条件

C#反射（Reflection）

反射指程序可以访问、检测和修改它本身状态或行为的一种能力。

程序集包含模块，而模块包含类型，类型又包含成员。反射则提供了封装程序集、模块和类型的对象。

您可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。然后，可以调用类型的方法或访问其字段和属性。

优缺点

优点：

  • 1、反射提高了程序的灵活性和扩展性。
  • 2、降低耦合性，提高自适应能力。
  • 3、它允许程序创建和控制任何类的对象，无需提前硬编码目标类。

缺点：

  • 1、性能问题：使用反射基本上是一种解释操作，用于字段和方法接入时要远慢于直接代码。因此反射机制主要应用在对灵活性和拓展性要求很高的系统框架上，普通程序不建议使用。
  • 2、使用反射会模糊程序内部逻辑；程序员希望在源代码中看到程序的逻辑，反射却绕过了源代码的技术，因而会带来维护的问题，反射代码比相应的直接代码更复杂。

反射（Reflection）的用途

反射（Reflection）有下列用途：

  • 它允许在运行时查看特性（attribute）信息。
  • 它允许审查集合中的各种类型，以及实例化这些类型。
  • 它允许延迟绑定的方法和属性（property）。
  • 它允许在运行时创建新类型，然后使用这些类型执行一些任务。

查看元数据

我们已经在上面的章节中提到过，使用反射（Reflection）可以查看特性（attribute）信息。

System.Reflection 类的 MemberInfo 对象需要被初始化，用于发现与类相关的特性（attribute）。为了做到这点，您可以定义目标类的一个对象，如下：

1
System.Reflection.MemberInfo info = typeof(MyClass);

c#属性(Property)及访问器(Accessors)

属性（Property）的访问器（accessor）包含有助于获取（读取或计算）或设置（写入）属性的可执行语句。访问器（accessor）声明可包含一个 get 访问器、一个 set 访问器，或者同时包含二者。

C# 索引器（Indexer）

索引器（Indexer） 允许一个对象可以像数组一样使用下标的方式来访问。当您为类定义一个索引器时，该类的行为就会像一个 虚拟数组（virtual array） 一样。您可以使用数组访问运算符 [ ] 来访问该类的的成员。

C# 委托（Delegate）

C# 中的委托（Delegate）类似于 C 或 C++ 中函数的指针。委托（Delegate） 是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。

委托（Delegate）特别用于实现事件和回调方法。所有的委托（Delegate）都派生自 System.Delegate 类。

委托的多播（Multicasting of a Delegate）

委托对象可使用 “+” 运算符进行合并。一个合并委托调用它所合并的两个委托。只有相同类型的委托可被合并。”-“ 运算符可用于从合并的委托中移除组件委托。

使用委托的这个有用的特点，您可以创建一个委托被调用时要调用的方法的调用列表。这被称为委托的 多播（multicasting），也叫组播。

C#事件

事件（Event） 基本上说是一个用户操作，如按键、点击、鼠标移动等等，或者是一些提示信息，如系统生成的通知。应用程序需要在事件发生时响应事件。例如，中断。

C# 中使用事件机制实现线程间的通信。

通过事件使用委托

事件在类中声明且生成，且通过使用同一个类或其他类中的委托与事件处理程序关联。包含事件的类用于发布事件。这被称为 发布器（publisher） 类。其他接受该事件的类被称为 订阅器（subscriber） 类。事件使用 发布-订阅（publisher-subscriber） 模型。

发布器（publisher） 是一个包含事件和委托定义的对象。事件和委托之间的联系也定义在这个对象中。发布器（publisher）类的对象调用这个事件，并通知其他的对象。

订阅器（subscriber） 是一个接受事件并提供事件处理程序的对象。在发布器（publisher）类中的委托调用订阅器（subscriber）类中的方法（事件处理程序）。

事件的整个过程是：订阅 -> 发布 -> 执行。事件的整个过程是：订阅 -> 发布 -> 执行。

  • 订阅: 假设事件 A 的执行方法是 F_A，事件 B 的执行方法是 F_B，将这些事件与它们的委托人进行绑的行为就是订阅，这个委托人就是发布器的一个成员。订阅器另一个行为就是在订阅之后（必学先订阅）通知发布器的相关成员。
  • 发布： 首先要明确事件发布的类型（由事件的执行方法参数列表决定）和要发布事件的变量（这个变量即委托人）；其次整理发布所需的材料、判断条件是否合适等；最后让内部的委托人向执行函数传递最终信息。
  • 执行： 是整个事件最后完成的步骤，就是普通的函数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
using System;
namespace SimpleEvent
{
  /***********发布器类***********/
  public class EventTest
  {
    public delegate void NumManipulationHandler(); //声明委托
    public event NumManipulationHandler ChangeNum; //声明事件

    public void OpenDoor()
    {
        ChangeNum();  //事件触发
    }
  }

  /***********订阅器类***********/
  public class subscribEvent
  {
    public void printf()
    {
      Console.WriteLine( "The door is opened." );
    }
  }

  /***********触发***********/
  public class MainClass
  {
    public static void Main()
    {
      EventTest e = new EventTest(); /* 实例化事件触发对象 */
      subscribEvent v = new subscribEvent(); /* 实例化订阅事件对象 */
        
        /* 订阅器的printf()在事件触发对象中注册到委托事件中 */
      e.ChangeNum += new EventTest.NumManipulationHandler( v.printf ); 
      e.OpenDoor(); /* 触发了事件 */
    }
  }
}

delegate 相当于定义一个函数类型。

event 相当于定义一个 delegate 的函数指针（回调函数指针）。

这样就好理解了。

再看一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
using System;
namespace CarEvent
{
    public class Car
    {
        // 申明委托
        public delegate void CarEngineHandler(string msg);
        // 创建委托实例Exploded和AboutToBlow事件
        public event CarEngineHandler Exploded;
        public event CarEngineHandler AboutToBlow;
        //设置属性
        public int CurrentSpeed { get; set; }
        public int MaxSpeed { get; set; }
        public string PetName { get; set; }
        public bool CarIsDead;//用于判断是否超速
        
        public Car()//构造函数
        {
            MaxSpeed = 100;
        }

        public Car(string name, int maxSp, int currSp)//构造函数重载

        {
            CurrentSpeed = currSp;
            MaxSpeed = maxSp;
            PetName = name;
        }

        public void Accelerate(int delta)//用于触发Exploded和AboutToBlow事件
        {            
            CurrentSpeed += delta;//"踩油门"加速
            if (CurrentSpeed >= MaxSpeed)//判断时速  
                CarIsDead = true;    
            else
                CarIsDead = false;
            if (CarIsDead)// 如果Car超速了，触发Exploded事件
            {
                if (Exploded != null)//判断是否被委托联系起来
                {
                    Exploded("sorry,this car is dead");//调用CarDead事件
                }
            }
            else
            {    //如果没有超速，则提示快要超速并显示实时车速
                if ((MaxSpeed - CurrentSpeed) > 0 && (MaxSpeed - CurrentSpeed) <= 10 && AboutToBlow != null)//判断是否被委托联系起来且速度是否接近临界值
                {
                    AboutToBlow("careful buddy ! gonna blow !");//调用NearDead事件 
                    Console.WriteLine("CurrentSpeed={0}",CurrentSpeed);//显示实时车速
                }
            }
        }
    }

    //订阅类书写举例
    public class Answer
    {
        public void CarDead(string msg)//汽车已爆缸事件
        {
            Console.WriteLine("sorry,this car is dead");
        }

        public void NearDead(string msg)//汽车快要爆缸事件
        {
            Console.WriteLine("careful buddy ! gonna blow !");
        }
    }

    //主函数书写
    public class test
    { 
        static void Main(string[] args)
        { 
            Car c = new Car("奔驰",100,93);//创建实例并初始化，初始速度为93
            Answer an = new Answer();
            c.Exploded += new Car.CarEngineHandler(an.CarDead);//Exploded"绑定"CarDead
            c.AboutToBlow += new Car.CarEngineHandler(an.NearDead);//AboutToBlow"绑定"NearDead
            c.Accelerate(6);//第一次加速，时速小于100，引发的事件为"快要爆缸"并显示实时车速为99
            Console.ReadLine();//等待回车键已启动第二次加速
            c.Accelerate(2);//第二次加速，时速超过100，引发的事件为"已爆缸"，不显示车速
            Console.ReadKey();
        }
    }
}

C# 集合（Collection）

集合（Collection）类是专门用于数据存储和检索的类。这些类提供了对栈（stack）、队列（queue）、列表（list）和哈希表（hash table）的支持。大多数集合类实现了相同的接口。

1
using System.Collections;

C# 泛型（Generic）

是指将类型参数化以达到代码复用提高软件开发工作效率的一种数据类型。

泛型的实质是，将类型作为参数，添加到接口、类或者方法中，以提高接口、类和方法对对不同类型数据的适应性。由于带泛型的这些数据结构扩大了对不同类型的适应、兼容，这些数据结构就可以在更广的范围内进行复用，从而使程序的可复用性得到增加，提高代码的优雅性。

.NET框架2.0的类库提供一个新的命名空间System.Collections.Generic，其中包含了一些新的基于泛型的容器类。如List

使用场景

  • 泛型参数
  • 泛型方法
  • 泛型类
  • 泛型委托
  • 泛型接口

泛型约束

下表列出了五类约束：

约束 描述
where T: struct 类型参数必须为值类型。
where T : class 类型参数必须为类型。
where T : new() 类型参数必须有一个公有、无参的构造函数。当于其它约束联合使用时,new()约束必须放在最后。
where T : 类型参数必须是指定的基类型或是派生自指定的基类型。
where T : 类型参数必须是指定的接口或是指定接口的实现。可以指定多个接口约束。接口约束也可以是泛型的。

泛型代码中的 default 关键字：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
在泛型类和泛型方法中会出现的一个问题是，如何把缺省值赋给参数化类型，此时无法预先知道以下两点：
l        T将是值类型还是引用类型
l        如果T是值类型，那么T将是数值还是结构
 
对于一个参数化类型T的变量t，仅当T是引用类型时，t = null语句才是合法的； t = 0只对数值的有效，而对结构则不行。这个问题的解决办法是用default关键字，它对引用类型返回空，对值类型的数值型返回零。而对于结构，它将返回结构每个成员，并根据成员是值类型还是引用类型，返回零或空。下面MyList<T>类的例子显示了如何使用default关键字。更多信息，请参见泛型概述。
 
public class MyList<T>
{
    //...
        public T GetNext()
        {
            T temp = default(T);
            if (current != null)
            {
                temp = current.Data;
                current = current.Next;
            }
            return temp;
        }
}

以下是 C# 泛型和 C++ 模板之间的主要差异：

  • C# 泛型的灵活性与 C++ 模板不同。 例如，虽然可以调用 C# 泛型类中的用户定义的运算符，但是无法调用算术运算符。
  • C# 不允许使用非类型模板参数，如 template C<int i> {}。
  • C# 不支持显式定制化；即特定类型模板的自定义实现。
  • C# 不支持部分定制化：部分类型参数的自定义实现。
  • C# 不允许将类型参数用作泛型类型的基类。
  • C# 不允许类型参数具有默认类型。
  • 在 C# 中，泛型类型参数本身不能是泛型，但是构造类型可以用作泛型。 C++ 允许使用模板参数。
  • C++ 允许在模板中使用可能并非对所有类型参数有效的代码，随后针对用作类型参数的特定类型检查此代码。 C# 要求类中编写的代码可处理满足约束的任何类型。 例如，在 C++ 中可以编写一个函数，此函数对类型参数的对象使用算术运算符 + 和 -，在实例化具有不支持这些运算符的类型的模板时，此函数将产生错误。 C# 不允许此操作；唯一允许的语言构造是可以从约束中推断出来的构造。

Lambda 表达式

使用 Lambda 表达式来创建匿名函数。 使用 lambda 声明运算符=> 从其主体中分离 lambda 参数列表。 Lambda 表达式可采用以下任意一种形式：

  • 表达式 lambda，表达式为其主体：

    C#复制

    1
    (input-parameters) => expression

  • 语句 lambda，语句块作为其主体：

    C#复制

    1
    (input-parameters) => { <sequence-of-statements> }

若要创建 Lambda 表达式，需要在 Lambda 运算符左侧指定输入参数（如果有），然后在另一侧输入表达式或语句块。

任何 Lambda 表达式都可以转换为委托类型。 Lambda 表达式可以转换的委托类型由其参数和返回值的类型定义。 如果 lambda 表达式不返回值，则可以将其转换为 Action 委托类型之一；否则，可将其转换为 Func 委托类型之一。 例如，有 2 个参数且不返回值的 Lambda 表达式可转换为 Action 委托。 有 1 个参数且不返回值的 Lambda 表达式可转换为 Func 委托。 以下示例中，lambda 表达式 x => x * x（指定名为 x 的参数并返回 x 平方值）将分配给委托类型的变量：

C#复制运行

1
2
3
4
Func<int, int> square = x => x * x;
Console.WriteLine(square(5));
// Output:
// 25

表达式 lambda 还可以转换为表达式树类型，如下面的示例所示：

C#复制运行

1
2
3
4
System.Linq.Expressions.Expression<Func<int, int>> e = x => x * x;
Console.WriteLine(e);
// Output:
// x => (x * x)

可在需要委托类型或表达式树的实例的任何代码中使用 lambda 表达式，例如，作为 Task.Run(Action) 方法的参数传递应在后台执行的代码。 用 C# 编写 LINQ 时，还可以使用 lambda 表达式，如下例所示：

C#复制运行

1
2
3
4
5
int[] numbers = { 2, 3, 4, 5 };
var squaredNumbers = numbers.Select(x => x * x);
Console.WriteLine(string.Join(" ", squaredNumbers));
// Output:
// 4 9 16 25

如果使用基于方法的语法在 System.Linq.Enumerable 类中（例如，在 LINQ to Objects 和 LINQ to XML 中）调用 Enumerable.Select 方法，则参数为委托类型 System.Func。 如果在 System.Linq.Queryable 类中（例如，在 LINQ to SQL 中）调用 Queryable.Select 方法，则参数类型为表达式树类型 Expression>。 在这两种情况下，都可以使用相同的 lambda 表达式来指定参数值。 尽管通过 Lambda 创建的对象实际具有不同的类型，但其使得 2 个 Select 调用看起来类似。

C# 不安全代码

当一个代码块使用 unsafe 修饰符标记时，C# 允许在函数中使用指针变量。不安全代码或非托管代码是指使用了指针变量的代码块。

C# 多线程

线程 被定义为程序的执行路径。每个线程都定义了一个独特的控制流。如果您的应用程序涉及到复杂的和耗时的操作，那么设置不同的线程执行路径往往是有益的，每个线程执行特定的工作。

线程是轻量级进程。一个使用线程的常见实例是现代操作系统中并行编程的实现。使用线程节省了 CPU 周期的浪费，同时提高了应用程序的效率。

到目前为止我们编写的程序是一个单线程作为应用程序的运行实例的单一的过程运行的。但是，这样子应用程序同时只能执行一个任务。为了同时执行多个任务，它可以被划分为更小的线程。

线程生命周期

线程生命周期开始于 System.Threading.Thread 类的对象被创建时，结束于线程被终止或完成执行时。

下面列出了线程生命周期中的各种状态：

  • 未启动状态：当线程实例被创建但 Start 方法未被调用时的状况。

  • 就绪状态：当线程准备好运行并等待 CPU 周期时的状况。

  • 不可运行状态

    ：下面的几种情况下线程是不可运行的：

    • 已经调用 Sleep 方法
    • 已经调用 Wait 方法
    • 通过 I/O 操作阻塞

  • 死亡状态：当线程已完成执行或已中止时的状况

主线程

在 C# 中，System.Threading.Thread 类用于线程的工作。它允许创建并访问多线程应用程序中的单个线程。进程中第一个被执行的线程称为主线程。

当 C# 程序开始执行时，主线程自动创建。使用 Thread 类创建的线程被主线程的子线程调用。您可以使用 Thread 类的 CurrentThread 属性访问线程。

下面的实例演示了 sleep() 方法的使用，用于在一个特定的时间暂停线程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
using System;
using System.Threading;

namespace MultithreadingApplication
{
    class ThreadCreationProgram
    {
        public static void CallToChildThread()
        {
            Console.WriteLine("Child thread starts");
            // 线程暂停 5000 毫秒
            int sleepfor = 5000;
            Console.WriteLine("Child Thread Paused for {0} seconds",
                              sleepfor / 1000);
            Thread.Sleep(sleepfor);
            Console.WriteLine("Child thread resumes");
        }

        static void Main(string[] args)
        {
            //ThreadStart childref = new ThreadStart(CallToChildThread);
            Console.WriteLine("In Main: Creating the Child thread");
            //Thread childThread = new Thread(childref);     //在2.0以后可以直接执行子线程，这样一来程序可以省略Main函数中的第一行代码
            Thread childThread = new Thread(CallToChildThread);
            childThread.Start();
            Console.ReadKey();
        }
    }
}

销毁线程

Abort() 方法用于销毁线程。

通过抛出 threadabortexception 在运行时中止线程。这个异常不能被捕获，如果有 finally 块，控制会被送至 finally 块。

下面的程序说明了这点：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
using System;
using System.Threading;

namespace MultithreadingApplication
{
    class ThreadCreationProgram
    {
        public static void CallToChildThread()
        {
            try
            {

                Console.WriteLine("Child thread starts");
                // 计数到 10
                for (int counter = 0; counter <= 10; counter++)
                {
                    Thread.Sleep(500);
                    Console.WriteLine(counter);
                }
                Console.WriteLine("Child Thread Completed");

            }
            catch (ThreadAbortException e)
            {
                Console.WriteLine("Thread Abort Exception");
            }
            finally
            {
                Console.WriteLine("Couldn't catch the Thread Exception");
            }

        }
       
        static void Main(string[] args)
        {
            ThreadStart childref = new ThreadStart(CallToChildThread);
            Console.WriteLine("In Main: Creating the Child thread");
            Thread childThread = new Thread(childref);
            childThread.Start();
            // 停止主线程一段时间
            Thread.Sleep(2000);
            // 现在中止子线程
            Console.WriteLine("In Main: Aborting the Child thread");
            childThread.Abort();
            Console.ReadKey();
        }
    }
}

C# 在 4.0 以后一共有3种创建线程的方式:

  • 1.Thread 自己创建的独立的线程, 优先级高,需要使用者自己管理。
  • 2.ThreadPool 有 .Net 自己管理, 只需要把需要处理的方法写好, 然后交个.Net Framework, 后续只要方法执行完毕, 则自动退出。
  • 3.Task 4.0 以后新增的线程操作方式, 类似 ThreadPool, 但效率测试比ThreadPool略高, Task对多核的支持更为明显,所以在多核的处理器中, Task的优势更为明显。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Program
{  
    static void Main(string[] args)
    {  //独立创建线程
        Thread t = new Thread(ThreadProcess);
        t.Start(new object());
        
        //线程池
        ThreadPool.QueueUserWorkItem(ThreadProcess, new object());
        //Task方式创建线程
        System.Threading.Tasks.Task.Factory.StartNew(ThreadProcess, new object());

        //需要手动终止,当然现在终止可能线程还未运行完成,
        t.Abort();
    }
    private static void ThreadProcess(object tag)
    {
        int i = 100;
        while (i > 0)
        {
            Console.WriteLine(string.Format("i:{0} ", i));
            Thread.Sleep(10);
            i--;
        }
    }
}
打赏
  • 版权声明： 本博客所有文章除特别声明外，著作权归作者所有。转载请注明出处！
  • Copyrights © 2019-2022 PAYIZ
  • |

感谢您的支持😊

支付宝
微信