C#是面向组件的语言 编程语言趋势：自包含 自描述

垃圾回收 异常处理 类型安全

C#继承与c++与Java的糅合

版本控制 virtual override

.cs作为扩展名

命名空间 程序 类型 成员 程序集

程序集的扩展名一般为 .dll（library）或者 .exe（application）。主要看其中是否包含main入口函数。

C#本身没有类库

X（）方法和委托调用

X is T

X as T

int [] 一维数组 int[][] 一维数组的一维数组 int[ , ]二维数组

C#的类型系统是统一的，任何类型的值都可以被处理成对象。

值的类型可以通过过boxing与unboxing操作处理成对象。

如： int i=0; object xx=I; int j=(int)xx;

重载 operator

语句：块（允许在只能使用单个语句的上下文中编写多个语句）、声明语句、表达式语句、选择语句（if、switch）、迭代语句（while、do、for、foreach）、跳转语句（break、continue、goto、throw、return）

try-catch：捕捉块语句执行过程中的异常

try-finally 指定一个终止代码块。无论异常与否，必被执行

checked与unchecked用于控制整形算术元素按与转换的溢出

lock用于获得给定对象的互斥锁，执行语句，然后释放该锁。

//using 用于获取一个资源，相当于#include或者import

//namespace相当于 package

foreach与freemarker中的语言相似 foreach( int x in nums){……}

注意foreach只是引用集合中元素的值，并不能改集合中元素的值。

try throw catch 一般条件判断，决定throw的内容，此处与java稍有不同

using获取一个资源，执行一个语句，然后处理该资源。

如：using(TextWriter w=File.CreateText("test.txt")){

w.WriteLine("Line One");

}

类的声明：

指定类的特性与修饰符 类名 基类 被该类实现的接口名 类体

使用new运算符创建实例（对象）

类的成员： 静态成员（类） 实例成员（对象）

类的访问性权限：public、protected、internal（仅限于当前程序集）、protected internal、private

类的声明，可在类名后面加上":"后面写上基类名字。省略基类名字的直接默认从object基类派生。

静态字段：static修饰的。他只表示一个存储位置。无论创建多少个实例，静态字段只有一个副本。（此特征可用作消息接口）

实例字段：每个对象都有自己独立的副本

方法：

静态方法：只能通过类来访问

实例方法：通过对象来访问

方法的签名：方法名、参数的数目、每个参数的修饰符与类型

参数：

值参数：相当于一个自变量。初始值是从该参数所传递的自变量获得的，对值参数的修改不会影响传递的自变量

引用参数：用雅虎输入和输出参数的传递。对饮用参数的修改影响传递的自变量。（ref）

输出参数：用于输出参数的传递，与引用参数类似。不同之处在于调用方提供的自变量的初始值始终无关紧要。（out）

参数数组：允许将可变长度的自变量列表传递给方法。只有方法的最后一个参数能够被声明为数组参数，而且数组参数必须是一维的。（params）带数组参数的

传递引用类型参数

引用类型的变量不直接包含其数据；它包含的是对其数据的引用。当通过值传递引用类型的参数时，有可能更改引用所指向的数据，如某类成员的值。但是无法更改引用本身的值（指针值）；也就是说，不能使用相同的引用为新类分配内存并使之在块外保持。若要这样做，请使用 ref（或 out）关键字传递参数。为了简单起见，以下示例使用 ref。

方法调用中，既可以传递参数数组类型的单个变量，也可以传递参数数组的元素类型的若干个变量。对于后者情形，数组将被自动创建，并且通过给定的自变量初始化。

方法体与局部变量：与java一样，在获得局部变量值之前，必须对其明确赋值。

静态方法与实例方法：静态方法不对具体的实例进行操作，只能访问静态成员。实例方法技能访问静态成员也可以访问实例成员。在调用实例方法的实例上可以通过this来访问该实例本身。静态方法中使用this是错误的。

虚拟方法、重写方法、抽象方法：在一个虚拟方法的调用中，调用所涉及的实例的运行时类型确定了调用的应该是该方法的哪一个实现，非虚拟方法主要靠编译时类型确定方法的选取。虚拟方法用于引入新方法，而重写虚拟方法声明则用于使现有上网继承方法专用化，virtual
抽象方法：没有实现的虚拟方法。Abstract 只允许在抽象类中使用抽象方法

委托：函数指针的类似作用，用于调用一些方法体。这样可以避免相同方法体的重复编写，而可以再不同的类中直接使用。

接口是一种不包含操作实现部分的实现类

抽象类

消息：

类的修饰符：

Abstract：抽象类。不可用来创建实例，尽可用于生成继承类。

Internal： 该类尽可见于同一个程序集中。

New： 只用于嵌套类，指明类隐藏一个同名的被继承成员。

Private： 嵌套类。仅可被定义类本身访问。

Protected：嵌套类。只能从定义类的派生类中访问。

Public： 任何人都可以声明该类对象的额引用，或者访问它的公共成员。

Sealed： 不能作为其他类的基类、（有点类似Java中的final修饰符）

类的成员：

域：成员变量。修饰符：public，private，internal，protected。静态域、实例域

属性：一个提供对一个对象或类的特性进行访问的类成员。 属性的声明包括特定的集合：1个new修饰符与4个访问修饰符（static、virtual、override、abstract）

方法：1个new修饰符与4个访问修饰符（static、virtual、override、abstract）注意：在一个方法中定义另一个方法是语法错误的。但可以在一个方法体内调用另一个方法

嵌套类与嵌套接口：

构造函数：构造函数被public、internal、以外的修饰符（protected、protected internal与private）修饰，则必须显示的写出析构函数。

System.String是不可变的字符串。System.StringBuilder存放了一个可变的字符串，并提供一些对这个字符串修改的方法。

const关键字用来声明编译时常量，readonly用来声明运行时常量。

不可以将非静态的方法写成静态的，也不可以将非virtual的方法写成virtual。因为覆写方法的时候，两个方法的签名必须一致。唯一的例外是将virtual换成override。

索引器：允许按照数组的额方式索引对象的数组元素。带参数的属性

属性：对对象或者类的特性进行访问的类成员。Get访问器不需要参数，但返回值的类型必须与指定的一致。Set也不需要参数，编译器假定他带一个参数，其类型与属性值相同，表示为value。属性是作为域成员在类中定义的。

实现一个delegate是很简单的，通过以下3个步骤即可实现一个delegate：

1. 声明一个delegate对象，它应当与你想要传递的方法具有相同的参数和返回值类型

2．  创建delegate对象，并将你想要传递的函数作为参数传入。
3．  在要实现异步调用的地方，通过上一步创建的对象来调用方法。

结合delegate的实现，我们可以将自定义事件的实现归结为以下几步：

1．  定义delegate对象类型，它有两个参数，第一个参数是事件发送者对象，第二个参数是事件参数类对象。
2． 定义事件参数类，此类应当从System.EventArgs类派生。如果事件不带参数，这一步可以省略。
3． 定义事件处理方法，它应当与delegate对象具有相同的参数和返回值类型。
4． 用event关键字定义事件对象，它同时也是一个delegate对象。
5． 用+=操作符添加事件到事件队列中（-=操作符能够将事件从队列中删除）。
6 在需要触发事件的地方用调用delegate的方式写事件触发方法。一般来说，此方法应为protected访问限制，既不能以public方式调用，但可以被子类继承。名字是OnEventName。
7． 在适当的地方调用事件触发方法触发事件。

using System;
public class EventTest
{
        // 步骤1，定义delegate对象
     public delegate void MyEventHandler(object sender, System.EventArgs e);
     // 步骤2省略
     public class MyEventCls //监控处理事件执行的类
     {

     // 步骤3，定义事件处理方法，它与delegate对象具有相同的参数和返回值类// 型
     public void MyEventFunc(object sender, System.EventArgs e)
            {
                   Console.WriteLine("My event is ok!");
            }
     }

     // 步骤4，用event关键字定义事件对象
     private event MyEventHandler myevent;

     private MyEventCls myecls;

     public EventTest()
     {
            myecls = new MyEventCls();
            // 步骤5，用+=操作符将事件添加到队列中
            this.myevent += new MyEventHandler(myecls.MyEventFunc);

注意此处用得是+=，而不是Java中常见的.add。
     }

     // 步骤6，以调用delegate的方式写事件触发函数
     protected void OnMyEvent(System.EventArgs e)
     {
            if(myevent != null)
                   myevent(this, e);
     }

     public void RaiseEvent()
     {
            EventArgs e = new EventArgs();
            // 步骤7，触发事件
            OnMyEvent(e);
     }
     
     public static void Main()
     {
            EventTest et = new EventTest();
            Console.Write("Please input ‘a‘:");
            string s = Console.ReadLine();
            if(s == "a")
            {
                   et.RaiseEvent();
            }
            else
            {
                   Console.WriteLine("Error");
            }
     }
}

event属性支持add和remove关键字来代替get和set

C#中类的继承只能单继承，但可以通过接口实现多继承。（类Java）

所以没有虚基类的概念

基类中的构造函数与析构函数不可以被继承。其余的无条件被继承。那些修饰符的限定，只是影响派生类中的成员对基类中成员的访问权限问题。

只有可访问的方法才可以被重载。

Base访问基类成员 密封类：sealed 一般和override连用

抽象类可具体实现属性，但接口中属性与索引都仅仅是声明，由相关类去实现。

接口纯粹是一种设计表达式，类是设计与实现的集合。

如果类实现了某个接口，那么一而继承了其所有父接口。

隐藏接口属性，但可以用完全限定名访问父接口。

使用接口：如果事先知道某个类实现该接口，则可以通过类的对象直接进行访问该接口。

数组：由类型相同的元素组成

Type Name[] 或者 Type[] Name

C#中数组的初始化运用new

声明数组并不实际创建它们。在 C# 中，数组是对象，必须进行实例化。如果提供了初始值设定项，则还可以省略 new 运算符。

交错数组：int[][] numbers = { new int[] {2,3,4}, new int[] {5,6,7,8,9} };

int[][] numbers = new int[][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} };

访问数组成员可以直接进行，类似于在 C/C++ 中访问数组成员。

C# 还提供 foreach 语句。该语句提供一种简单、明了的方法来循环访问数组的元素。由于有了多维数组，可以使用相同方法来循环访问元素。

在 C# 中，数组实际上是对象。System.Array 是所有数组类型的抽象基类型。可以使用 System.Array 具有的属性以及其他类成员。

数组常用方法：

Length属性:表示数组所有维数中元素的总数。

Rank属性：表示数组中的维数。

Sort方法:对一维数组排序。它是Array类的静态方法.（意味着要通过Array类才可以访问）

Reverse方法:反转一维数组

GetLowerBound与GetUpperBound方法：数组指定维度的下限与上限

Clear方法 重新初始化数组中所有的元素 将数组中的一系列元素设置为零、false 或空引用.

C#中数组大小是固定的。与Java类似。

集合：

列表：声明：List<类型>列表名 其中类型可以使几百呢类型，也可以是用户自定义类型。

获得其大小：List.Capacity既可以

搜索元素：IndexOf() ：用于搜索列表中元素的索引号

LastIndexOf()：用于搜索列表指定元素的最后一个索引号

FindIndex()：用于检索元素在列表中出现的第一个位置

FindLastIndex()：用于检索元素在列表中出现的最后一个位置

Find()：搜索列表中匹配的第一个对象

FindLast()：搜索列表中匹配的最后一个对象

Exists()：检查元素是否存在

删除集合元素：RemoveAt()：按照索引键删除指定元素

RemoveAll()：删除列表中所有元素

RemoveRange()：从集合中删除多个元素

Clear()：清除列表中所有元素

.System.Collections中可以直接使用的集合类有：

ArrayList

实现了接口：IList、ICollection、IEnumerable

只要集合未被修改，ArrayList 就可安全地同时支持多个读取器

随着向 ArrayList 中添加元素，容量通过重新分配按需自动增加(2倍增加)

如果需要建立一个对象数组，但不能预先知道数组的大小，就可以使用ArrayList

ArrayList把所有元素都当作object对象引用，因而在访问ArrayList的元素时要进行类型转换

优点：动态改变大小、灵活方便的插入和删除元素、可排序

缺点：插入时性能不如数组、不是强类型的

BitArray

实现了接口：ICollection、IEnumerable

管理位值的压缩数组。

3)Hashtable

实现了接口：IDictionary、ICollection、IEnumerable

可以向Hashtable中自由添加和删除元素，有些像ArrayList，但没有那么大的性能开销

4)SortedList

实现了接口：IDictionary、ICollection、IEnumerable

SortedLIst兼顾了ArrayList和Hashtable的优点，可按键值来排序

5)Queue

实现了接口：ICollection、IEnumerable

Queque是队列，先进先出的访问各个元素

可以调用Queque对象的GetEnumerator()方法，得到IEnumerator对象，来遍历队列中的各个元素

6)Stack

实现了接口：ICollection、IEnumerable

Stack是堆栈，后进先出的访问各个元素

可以调用Stack对象的GetEnumerator()方法，得到IEnumerator对象，来遍历堆栈中的各个元素

队列：先进先出。在一段插入另一端删除。

非泛型;System.Collections.Queue

泛型：System.Collection.Generic.Queue<T>

Enqueue 在队的一端增加一个元素

Dequeue在队的另一端读取删除一个数据

Peek()在队里的头部读取一个数据，但不删除他

Count：返回队列中元素的额个数

TrimExccess()：重新设置队列的容量。因为Dequeue读取删除数据，但会留下空元素继续占位。

Contains：确定某个元素是否在队列中

CopyTo：将元素从队列中复制到一个已有的数组

ToArray：返回一个包含队列元素的新数组

栈（Stack）：先进先出 push（）出栈 pop（）进栈

链表：物理上散存，逻辑上连续的

List：返回与节点相关的LinkedList

Next：返回下一个节点

Previous：返回上一个节点

Value：返回与节点相关的元素，其类型为T

Cout First Last AddAfter（） Addbefore（）AddFirst（） AddLast（）

Remove（） RemoveFirst（） RemoveLast（）

Clear（） contains（）

Find（）从链表的开头搜索传给他的元素

FindLast（） 从链表的尾部开始寻找

有序表（SortedList）：key与values属性的集合对键和值进行高效的索引检索

ContainsKey()，ContainsValue 用于检查是否包含指定的Key活Value

TryGetValue