C#编程精华总结

C#学习总结

C#简介：

1、C#是一种最新的、面向对象的编程语言

2、C#使得程序员可以在Microsoft开发的最新的.NET平台上快速地编写Windows应用程序

3、而且Microsoft .NET提供了一系列的工具和服务应用在应用程序的开发中

4、C#语言是是建立在Microsoft的.NET Framework之上，专门为与.NET Framework一起使用而设计的。

5、.NET Framework是一个功能非常丰富的平台，可开发、部署和执行分布式应用程序。

6、C# 与.NET Framework的紧密结合使得程序开发更轻松、更高效。  

C#与.NET的关系 

1、C# 是一种编程语言，用于生成面向.NET环境的代码，但不是.NET的一部分。

2、.NET所支持的一些特性，C# 并不支持；而C# 支持的一些特性，.NET也可能不支持（如运算符重载）。

3、由于C# 是和.NET一起使用的，所以如果读者想更高效地利用C# 开发应用程序，掌握.NET Framework的相关知识就非常重要。在许多情况下，C# 的特定语言功能取决于.NET的功能或依赖于.NET基类。

4、Microsoft Visual Studio.NET是MicroSoft公司为适应Internet高速发展的需要而隆重推出的新的开发平台，是目前最流行的 Windows 平台应用程序开发环境，可以用来创建 Windows 平台下的 Windows 应用程序和网络应用程序，也可以用来创建网络服务、智能设备应用程序和 Office 插件。

C#内置的输入输出方法

1、Console.WriteLine("Hello World"); 指定了它的行为。

WriteLine 是一个定义在 System 命名空间中的 Console 类的一个方法。该语句会在屏幕上显示消息 "Hello, World!"

2、Console.ReadKey(); 是针对 VS.NET 用户的。这使得程序会等待一个按键的动作，防止程序从 Visual Studio .NET 启动时屏幕会快速运行并关闭。与C++的system("Pause");同效。

3、Console.Write（）与Console.WriteLine（）的区别是：前者输出后不换行，后者输出后自动换行

4、当 WriteLine() 函数有多个参数时，输出第一个参数中的内容，而第二个参数中的内容替换掉第一个参数中对应位置的占位符一起输出。

Console.WriteLine("A:{0}，a:{1}",65,97);

5、如果第一个参数没有留占位符,那么第二个参数内容不输出.

6、占位符从零开始计数,且占位符中的数字不能大于第二个参数的个数减一(要求占位符必须有可替换的值).占位符数字与第二个参数字符位置一一对应.

7、内置的 引用类型有：object、dynamic 和 string。

8、System 命名空间中的 Console 类提供了一个函数 ReadLine()，用于接收来自用户的输入，并把它存储到一个变量中。

例如： int num;

num = Convert.ToInt32(Console.ReadLine());

函数 Convert.ToInt32() 把用户输入的数据转换为 int 数据类型，因为 Console.ReadLine() 只接受字符串格式的数据

C# 中的构造函数

1、类的 构造函数 是类的一个特殊的成员函数，当创建类的新对象时执行。构造函数的名称与类的名称完全相同，它没有任何返回类型。

2、默认的构造函数没有任何参数。但是如果你需要一个带有参数的构造函数可以有参数，这种构造函数叫做参数化构造函数。这种技术可以帮助你在创建对象的同时给对象赋初始值，

3、一个类定义必须且至少有一个构造函数，如果定义类时，没有声明构造函数，系统会提供一个默认的构造函数，不带任何参数的构造函数称为默认构造函数。如果声明了构造函数，系统将不再提供默认构造函数。

4、为了创建实例的方便，一个类可以有多个具有不同参数列表的构造函数，即构造函数可以重载。

5、构造函数的访问属性一般被定义为Public

6、构造函数好像不能被调用？

C# 中的析构函数

1、类的 析构函数 是类的一个特殊的成员函数，当类的对象超出范围时执行。析构函数的名称是在类的名称前加上一个波浪形（~）作为前缀，它不返回值，也不带任何参数。析构函数用于在结束程序（比如关闭文件、释放内存等）之前释放资源。析构函数不能继承或重载。

类的成员

局部变量：在指定范围内有效。

字段：即类中的变量或常量，包括静态字段、 实例字段、常量和只读字段。

方法成员：包括静态方法和实例方法。

属性：按属性指定的get方法和Set方法对字段进行读写。属性本质上是方法。

事件：代表事件本身，同时联系事件和事件处理函数。

索引指示器：允许像使用数组那样访问类中的数据成员。

关于C# internal的解释

internal关键字是类型和类型成员的访问修饰符。只有在同一个程序集的文件中，内部类型或者是成员才可以访问。这是msdn上对internal的描述。只有这么一句话，但是具体怎么理解呢？类型就是enum（枚举类型），class（类），interface（接口），struct（结构）等类型。类型成员如函数，成员变量等。那么什么是程序集呢？根据msdn上通俗易懂的解释就是，一个完整的.exe或者是.dll文件就是一个程序集。

C#中常用的类的修饰符

public：表示不限制对该类的访问。

protected：表示只能对其所在类和所在类的子类进行访问。

internal：不允许外部程序集使用该类。//这就是微软自带库的类被定义为public的原因吗，（一般我们不会把一个类定义为internal）

解释：其实这个内部就是“同一程序集”的内部，也就是说，internal修饰的方法或者属性，只要是在同一个程序集的中的其他类都可以访问，如果二者不在同一命名空间，只要使用using引用上相应的命名空间即可，这里，从另外一个方面也间接看出命名空间并不是界定访问级别的，而是保证全局的类唯一性的。

private：只有.NET中的应用程序或库才能访问。//????把类定义为private有什么用？

new：仅允许在嵌套类声明时使用，表明类中隐藏了由基类中继承而来的、与基类中同名的成员。

abstract：抽象类，不允许建立类的实例。

sealed：密封类，不允许被继承。

自己的总结：

protected 只有自己的派生类可见。
internal只有自己包内的程序可见
protected internal 只有自己包内的派生类可见。

类成员访问修饰符

Private：私有数据成员只能被类内部的函数使用和修改，私有函数成员只能被类内部的函数调用。派生类虽然继承了基类私有成员，但不能直接访问它们，只能通过基类的公有成员访问。

Protected：保护数据成员只能被类内部和派生类的函数使用和修改，保护函数成员只能被类内部和派生类的函数调用。

Public：类的公用函数成员可以被类的外部程序所调用，类的公用数据成员可以被类的外部程序直接使用。公有函数实际是一个类和外部通讯的接口，外部函数通过调用公有函数，按照预先设定好的方法修改类的私有成员和保护成员。

Internal：内部成员只能在同一程序集中的文件中才是可以访问的，一般是同一个应用(Application)或库(Library)。

                  

默认访问权限问题：

1、访问标识符指定了对类及其成员的访问规则。如果没有指定，则使用默认的访问标识符。类的默认访问标识符是 internal，成员(包括属性和方法)的默认访问标识符是 private。

C# 类的静态成员

1、我们可以使用 static 关键字把类成员定义为静态的。当我们声明一个类成员为静态时，意味着无论有多少个类的对象被创建，只会有一个该静态成员的副本。

关键字 static 意味着类中只有一个该成员的实例。静态变量用于定义常量，因为它们的值可以通过直接调用类而不需要创建类的实例来获取。静态变量可在成员函数或类的定义外部进行初始化。你也可以在类的定义内部初始化静态变量。

2、静态变量只能通过“类.静态变量名”调用，类的实例不能调用； 非静态变量当该变量所在的类被实例化后，可通过实例化的类名直接访问。 

3、静态变量是全局变量，被所有类的实例对象共享，即一个实例的改变了静态变量的值，其他同类的实例读到的就是变化后的值（非静态变量是局部变量，不共享的） ； 

4、静态成员不能访问非静态成员； 非静态成员可以访问静态成员。

静态和非静态方法

方法分为静态方法(方法声明中含有static修饰符 )和非静态方法(方法声明中没有static修饰符 )。

1.静态方法

(1)静态方法不对特定实例进行操作，在静态方法中引用this会导致编译错误。

(2)C#中通过关键字static来定义静态成员。和实例成员不同，使用静态成员时，圆点连接符的前面不再是某个具体的对象变量，而是类的名称。如Console.WriteLine和Console.ReadLine等方法就属于静态方法，使用时没有创建哪个具体的Console类的实例，而是直接使用类本身。

                      

2.非静态方法

非静态方法是对类的某个给定的实例进行操作，而且可以用this来访问该方法。

例如程序例7-4中的

CzMath c = new CzMath();

c.Swap(ref a, ref b);

而且在类的方法中通过this.number_name的方法引用某成员

就是先实例化CzMath的对象c，然后用对象c去调用非静态方法Swap()。

输出参数

1、在传递的参数前加out关键字，即可将该传递参数设置为一个输出参数。

2、与引用参数类似，输出参数也不开辟新的内存区域。它与引用型参数的差别在于，调用方法前无需对变量进行初始化。输出型参数用于传递方法返回的数据。

3、out修饰符后应跟随与形参的类型相同的类型声明。在方法返回后，传递的变量被认为经过了初始化。

          ……

       double ave;//ave未初始化

       CzMath m = new CzMath();

       m.Average(a, b, out ave);

         ……

 

      class CzMath

     {

        public void Average(int x, int y, out double z)

        {

            z = Convert.ToDouble(x + y) / 2;

        }

    }

 

字段概念及用途

字段也叫成员变量，表示存储位置，用来保存类的各种数据信息。

字段又可分为静态字段、实例字段、常量和只读字段。

例如:

private static int myvar;

private int myvar;

private const int myvar=5;

private readonly int myvar=6;

 属性的概念及用途

1、属性定义了得到和修改相联系的字段的方法。

2、C#中的属性更充分地体现了对象的封装性：不直接操作类的数据内容，而是通过访问器进行访问，借助于get和set方法对属性的值进行读写。

3、当读取属性时，执行get访问器的代码块；当向属性分配一个新值时，执行set访问器

例如，在Student类中可以通过Name属性来封装对私有字段name的访问：

public class Student

{

  private string name;//字段

  public string Name //属性//可定义多个属性实现多个字段的访问器

  {

    get { return name; }

    set { name = value; }

  }

}

4、作为类的特殊函数成员，get和set访问函数需要包含在属性声明的内部，而函数声明只需要写出get和set关键字即可。其中get访问函数没有参数，默认返回类型就是属性的类型，表示属性返回值；set访问函数的默认返回类型为void，且隐含了一个与属性类型相同的参数value，表示要传递给属性的值。

5、通过属性来访问隐藏的字段，例如：

Student s1 = new Student(“李明”);

Console.WriteLine(s1.Name);//调用get访问函数访问name字段

Console.WriteLine(“请输入新姓名：”);

s1.Name = Console.ReadLine();//调用set访问函数修改name字段

6、属性可以只包含一个访问函数，如只有get访问函数，那么属性的值不能被修改；如只有set访问函数，则表明属性的值只能写不能读。

7、属性的典型用法是一个共有属性对应封装一个私有或保护字段，但这并非强制要求。属性本质上是方法，在其代码中可以进行各种控制和计算。

8、注意:在C# 3.0中，提供了名为“自动属性”特征，它允许只写出属性及其访问函数的名称，编译就会自动生成所要封装的字段以及访问函数的执行代码。

例如，

public class Student

{

  public string Name { get；set;}//比如该自动属性封装的字段是那个怎么确定？

}

其效果和下面传统的定义方式是一样的：

public class Student

{

  private string name;//字段

  public string Name //属性

  {

    get { return name; }

    set { name = value; }

  }

}

基类和派生类

1、为避免层次结构过于复杂，C#中的类不支持多继承，即不允许一个派生类继承多个基类，只有在类和接口之间可以实现多继承。

2、.NET 类库本身在构造过程中就充分利用了继承技术。System.Object类是其他所有类的基类，不仅如此，C#是完全面向对象的编程语言，其中所有的数据类型都是从类中衍生而来，因此 System.Object类也是其他所有数据类型的基类。

3.访问基类成员

访问基类成员涉及隐藏基类成员和base关键字的使用。

(1)隐藏基类成员

     大多数情况下，派生类不会一成不变地继承基类中的所有成员，如可能希望在某些字段中存储不同的信息、在某些方法中执行不同的操作等。这时就需要通过new关键字来隐藏基类中的成员。

                             

(2) base关键字的使用

1.base关键字用来访问当前对象的基类对象，进而调用基类对象的成员。

例如,可以StudentLeader类的PrintInfo方法改写成：

public new void PrintInfo()

{

      base.PrintInfo();      

      Console.WriteLine(Duty);

 }

这样，派生类StudentLeader的PrintInfo()方法就调用了其隐藏的基类方法。

2.base的另外一个用途是在派生类中调用基类构造函数，例如，上例中StudentLeader类的构造函数可以改写为：

public StudentLeader(string a, string b, int c,string d):base(a, b, c)

{

        Duty = d;

}

其中，base(a, b, c)表示调用基类构造

           函数Student(a,b,c)。

虚拟方法和重写方法

1.派生类很少一成不变地去继承基类中的所有成员。

一种情况是派生类中的方法成员可以隐藏基类中同名的方法成员，这时通过关键字new对成员加以修饰；

另一种更为普遍和灵活的情况是将基类的方法成员定义为虚拟方法，而在派生类中对虚拟方法进行重写。

后者的优势在于它可以实现运行时的多态性，即程序可以在运行过程中确定应该调用哪一个方法成员。

2、基类的虚拟方法通过关键字virtual进行定义，而派生类的重写方法则通过关键字override进行定义。

抽象类和抽象方法

1>基类中的虚拟方法允许在派生类中进行重写，并在调用时动态地决定是执行基类的方法代码，还是执行哪一个派生类的方法代码。

2>C#中还可以为基类定义抽象方法，它强制性地要求所有派生类必须重写该方法（看6>）。

3>抽象方法使用关键字abstract定义，并且不提供方法的执行体。

例如：

     //抽象方法

    public abstract void Area();

4>包含抽象方法的类必须是抽象类，它也需要使用关键字abstract加以定义。

例如：

public abstract class Shape

{

//类的成员定义...

}

5>对于抽象类，不允许创建类的实例。

6>抽象类之间也可以进行继承。抽象类要求其所有派生类都继承它的抽象方法；而如果派生类不是抽象类，它就必须重写这些抽象方法并提供实现代码。

7>和虚拟方法类似，派生类中对抽象方法的重写也通过override关键字进行。抽象方法不能是私有的，而且抽象方法及其重写方法的访问限制应当相同。最后，抽象方法不能同时使用virtual关键字进行修饰。

【例7-11】抽象类和抽象方法。

    public abstract class Shape

    { //定义Shape抽象类

        public const double PI = 3.14;

        public abstract double area(); //抽象方法，不需要定义处理

    }

密封类和密封方法

1、抽象类本身无法创建实例，而强制要求通过派生类实现功能。与之相反的是，在C#中还可以定义一种密封类，它不允许从中派生出其他的类。密封类通常位于类的继承层次的最低层，或者是在其他一些不希望类被继承的情况下使用。

密封类使用关键字sealed定义，例如：

public sealed class Circle : Shape

{

//类的成员定义...

 }

2、说明

(1)有趣的是, 尽管密封类和抽象类是截然相反的两个概念，但它们并不冲突：一个类可以同时被定义为密封类和抽象类，这意味着该类既不能被继承、也不能被实例化。这只出现在一种情况之下，那就是该类的所有成员均为静态成员，Console类就是这样的一个类。

(2)类似的，如果方法在定义中使用了关键字sealed，它就成为密封方法。与密封类的不同之处在于密封类是指不允许有派生类的类，而密封方法则是指不允许被重写的方法。密封方法所在的类不一定是密封类（这一点与抽象方法不同），而如果该类存在派生类，那么在派生类中就必须原封不动地继承这个密封方法。此外， 密封方法本身也要求是一个重写方法（即sealed和override必须在方法定义中同时出现）

                         

c#中 foreach 用法

1、foreach循环用于列举出集合中所有的元素，foreach语句中的表达式由关键字in隔开的两个项组成。in右边的项是集合名，in左边的项是变量名，用来存放该集合中的每个元素。

2、该循环的运行过程如下：每一次循环时，从集合中取出一个新的元素值。放到只读变量中去，如果括号中的整个表达式返回值为true，foreach块中的语句就能够执行。一旦集合中的元素都已经被访问到，整个表达式的值为false，控制流程就转入到foreach块后面
的执行语句。

3、foreach语句经常与数组一起使用

遍历数组：foreach（type objName in collection/Array）

注： objName的数据类型type必须与collection/Array对象的类型相同或比它大。

必须注意的是，借助foreach，只能一一取得数组中的元素，并不能利用这种语句改变数组所存储的元素。

c#中 as与is 用法

4、对于多维数组foreach可一次性遍历整个数组，而for语句不行。

5、 as运算符用于在两个应用类型之间进行转换，如果转换失败则返回null，并不抛出异常，因此转换是否成功可以通过结果是否为null进行判断，并且只有在运行时才能判断。

例子    Object obj=new Object(); 

ClassA a= obj  as ClassA;

 if(a!=null)  //在if判断a是否为null

{

...

}

6、 is运算符用于检查对象是否与给定类型兼容，并不进行实际的转换。如果判断对象引用为null，则返回false。由于仅仅判断是否兼容，因此不会抛出异常。使用范围，只适用于引用类型转换、装箱转换和拆箱转换，而不支持值类型转换。

例子    if(obj is ClassA)

{

    ClassA a=(ClassA) obj;

   ... 

 }

7、在实际工作中尽量使用as运算符，而少使用（）运算符的显示转换的理由：

1> 无论是as和is运算符，都比世界使用（）运算符强制转换更安全。

2> 不会抛出异常，免除使用try···catch进行异常捕获的必要和系统开销，只需要判断是否为null。

3> 使用as比使用is性能更好（C#4.0权威指南上这么说），验证结果如下：第一次运行时有as时间更短（没有截图），但是多运行几次之后，结果如图。

c#中 object用法

object 类型是 .NET Framework 中 Object 的别名。 在 C# 的统一类型系统中，所有类型（预定义类型、用户定义类型、引用类型和值类型）都是直接或间接从 Object 继承的。 可以将任何类型的值赋给 object 类型的变量。 将值类型的变量转换为对象的过程称为装箱。 将对象类型的变量转换为值类型的过程称为取消装箱。

 

对C#中的Close()和Dispose()的浅显理解

1、Close负责关闭业务，Dispose负责销毁对象。Dispose会负责Close的一切事务，额外还有销毁对象的工作，即Dispose包含Close

2、当你有明确需求的时候，不要混用二者

3、两者连在一起用没什么意义。要么关闭~以便再次使用，要么销毁~不再使用

C# using 三种使用方式

1、using指令。using + 命名空间名

2、using别名。using + 别名 = 包括详细命名空间信息的具体的类型。 
这种做法有个好处就是当同一个cs引用了两个不同的命名空间，但两个命名空间都包括了一个相同名字的类型的时候。当需要用到这个类型的时候，就每个地方都要用详细命名空间的办法来区分这些相同名字的类型。而用别名的方法会更简洁，用到哪个类就给哪个类做别名声明就可以了。注意：并不是说两个名字重复，给其中一个用了别名，另外一个就不需要用别名了，如果两个都要使用，则两个都需要用using来定义别名的。

using aClass = NameSpace1.MyClass;

using bClass = NameSpace2.MyClass;

推荐使用using指令的方式。

3、using语句，定义一个范围，在范围结束时处理对象。

当在某个代码段中使用了类的实例，而希望无论因为什么原因，只要离开了这个代码段就自动调用这个类实例的Dispose。 
要达到这样的目的，用try...catch来捕捉异常也是可以的，但用using也很方便。

using (Class1 cls1 = new Class1(), cls2 = new Class1())

using (Class1 cls1 = new Class1(), cls2 = new Class1())

{

  // the code using cls1, cls2

} // call the Dispose on cls1 and cls2//销毁对象cls1 and cls2

C#组件的 Tag属性使用

1、在.NET中的类都派生于Object类，因此，可以为C#程序的Tag属性设置任意自定义的类型的对象或基本类型的值，方便程序在必要的时候读取。

2、Tag是很多.NET组件拥有的一个属性，它只是一个object类型的对象，你可以在编程中方便的使用。它可以是任意值……根据你程序的需要而赋值或者使用。

3、Tag属性是给开发人员留的，开发人员可以用它来存放自己想存放的信息

托管与非托管

非托管代码主要是基于win 32平台开发的DLL，activeX的组件，托管代码是基于.net平台开发的。如果您想深入了解托管与非托管的关系与区别，及它们的运行机制，请您自行查找资料，本文件在此不作讨论。

C#模块化程序设计

1、每一个窗口会有对应两部分代码，例如LoginForm.cs与LoginForm.designer.cs ,注意LoginForm.designer.cs完全是由系统自动生成的，这部分代码可以不怎么看，LoginForm.cs则是对应的每个控件的事件处理程序。

2、一个工程还可添加 .cs文件，一般跟界面无关的部分放到自己的 .cs文件中写，一个工程可能会添加多个 .cs文件。

3、每个工程都会只对应一个命名空间（方便同一工程文件间的调用），另外每个工程文件中的.cs文件（或对话框对应的 .cs文件）都会对应一个自己的类

一般每一工程的各个文件中所声明的命名空间名与工程名相同，而工程底下的各个文件中所声明的类名则与本文件名相同。

4、C#与C++的一重大区别是模块化编程时C++是通过包含各个.h文件实现，而C#是通过各个工程的不同的命名空间来实现。

5、C#代码不存在.h头文件，同一个工程下A下的A1.cs里可以直接引用的A2.cs里的内容的，若工程A想用工程B的东西，则需加入工程B的命名空间。

注意事项

1、在C#编程中注意一个.cs文件中定义了多个命名空间的话，引用其命名空间中的成员时要加namespace_name.或在文件头处加using namespace_name;

1、当有嵌套命名空间时：using Namespace1.SubNameSpace;

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

using static System.Math;

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

3、C++中当局部变量被定义时，系统不会对其初始化，您必须自行对其初始化。定义全局变量时，系统会自动对其初始化；而在C#中无论是局部变量还是全局变量系统都会对其初始化；

4、局部变量和全局变量的名称可不可以相同；

C++中是可以相同的，且局部变量会覆盖全局变量的值；C#中全局变量和局部变量的名称不可以相同；

5、函数参数类型为对象时：

  C++：当参数类型为对象时，函数在传参时进行对象的复制，在函数体里改变数组里的值，函数外面不会跟着改变；

  C# ：当参数类型为对象时，函数默认当成引用类型来处理，在函数体里改变数组里的值，函数外面也跟着改变； 

6、函数参数类型为数组时：

  C++：当参数类型为数组时，函数默认当成指针类型来处理，在函数体里改变数组里的值，函数外面也跟着改变；

  C# ：当参数类型为数组时，函数默认当成引用类型来处理，在函数体里改变数组里的值，函数外面也跟着改变； 

7、c#好像定义一个对象必须要通过new()的方式，声明的对象是未初始化的，不能直接使用。

C++:两种用法

ClassA objA;objA.FieldA=valueA;//对象法

ClassA * objA=new ClassA();objA->FieldA=valueA;//指针法

     C#:  ClassA objA=new ClassA();objA.FieldA=valueA; 

8、数组：
   以定义一个int类型的4行4列的二维数组arr为例：
   C#定义数组格式是: int[][] arr = new int[4][4];
   C++定义数组的格式是：int arr[4][4];

9、switch（参数类型）：
   C#参数类型可以是任何类型，C++则必须是整形。

11、函数返回值类型：
   C#里返回值基本上可以使任何类型，C++则不行，C++的函数返回值类型必须是除了函数和数组类型之外的其他任何类型。

12、 public static bool WriteLog(string userName, int type, DateTime dateTime, string description)//注意各修饰符出现的顺序。

13、C# 的宏定义必须出现在所有代码之前

14、C#读取配置文件的方法

 localIPAddress = ConfigurationManager.AppSettings["IPAddress"];//可得到本地IP地址

15、C#如果你的class没有写父类，就默认Object是你的父类。

16、C#程序要学会通过看函数上方提示的引用得到一些相关的信息。

17、C#程序的索引功能中对于本类的成员和对于本类的父类的成员的图标是不一样的，对于本类的成员是蓝色的，父类是一个灰色的扳手

18、C++中的结构体，在C#中称为实体

19、C#中当要使用某一个命名空间中的成员时，若该命名空间是自己新建的直接using 空间名 即可，若该命名空间为系统自带的，则可能需要手动添加引用。

20、当C#的一个解决方案下有多个工程的时候，一般新建工程时系统会自动给工程以工程名取名一个命名空间，

21、在.NET的对象中实际上有两个用于释放资源的函数：Dispose和Finalize。Finalize的目的是用于释放非托管的资源，而Dispose是用于释放所有资源，包括托管的和非托管的。

22、C#中某个类的方法对本类的成员的操作可以通过 this.  的方式，这样即使方法的形参就可以更类的成员同名。（我们的IDE会对可以不需要加this.的地方自动变灰）。

23、注意成员修饰符的顺序如：public static int A(),记住一般成员类型是紧跟成员的，如int要紧贴A,其他的顺序好像不重要

28、判断一string字符串是否为空  string.IsNullOrEmpty(textBoxAccount.Text)

29、格式化一字符串 string.Format("[尝试认证{0}次]", tryCount);

30、C#编写的代码风格与C++编写的代码风格一很大的区别是C#是直接在类里面写方法（成员函数）的具体内容（数据成员也是直接在类里定义的，界面编程在另外一个.designer.cs文件中），而C++是在类中声明，类外定义。

 C#在VS中的一些使用技巧

4、对一个函数的说明

先写一个函数，以及参数，完成后，在函数上输入///，vs会自动补全说明的信息，你写上自己的功能说明就好了，下次你调用此函数就会有相应的说明了

3、创建C#属性

在vs里输入prop，然后按两次Tab，这样就可以创建C#属性，然后用Tab来选中进行修改属性。同样的还有propa，和propdp。

4、帮助绑定选定项的选项快捷键

有时你在写一个类的时候，突然忘记他是那个using了，这个时候，比如Thread，你就可以用“shift+Alt+F10 ”来智能提示了。选中后，可以自动添加using。

5、对象重命名

可以使用快捷键“Crl+R“，”Crl+R“，这样就可以给你的函数名进行重命名或者变量重命名。

6、使用#region就是将一些有关联的代码组织在一起，然后折叠起来。这样你就在一个函数中看不到很长的令人头痛的代码段。

 

注：由于笔者水平有限，若博文中存在错误或不周之处，还望各位博友多多指教，有新的经验的时候也会及时更新本博文，谢谢！