代表主要有两个用途，一个是回调，另一个是事件处理。对于回调，代表就像是用typedef定义了一个指向函数的指针。代表需要用new来产生，代表也可以在形式上类似于类那样，来定义个该代表的对象，也可以作为对象作为函数参数进行传递。

nested loop的意思是嵌套循环，经常看到nested这个词，但一直不知道啥意思，现在总算知道了。

线程部分：
在System.Threading名空间中定义；
创建线程不必要利用到一个ThreadStart的代表，该代表来指定一个方法，这一方法就是线程执行的函数体；
启动线程用Start；
休眠线程用Sleep；
在.NET中，线程可以超越进程的界限，访问其他进程中的线程；
线程挂起有Sleep(0)和Suspend两种方法，第一种方法直到其他线程调用该线程的Interrupt来中断这种挂起状态，第二种方法会直到其他线程调用该线程的Resume才能恢复挂起的状态；
销毁线程用Abort。
一个典型例子：
class A
{
 public static void fun()
 {
  Console.WriteLine("Another Thread is running!");
 }
 
 public static void main()
 {
  ThreadStart t=new ThreadStart(fun);
  Console.WriteLine("Main Thread is running!");
  
  Thread thread=new Thread(t);
  thread.Start();
  
  Console.WriteLine("...");
 }
}

.NET中用Monitor类实现了类似于信号量的机制来对代码块进行串行化的访问。
Monitor.Enter(this);
代码块
Monitor.Exit(this);

C#中用lock实现了类似Monitor的功能，使用方法如下：
lock(this)
{
 代码块
}

可以通过Mutex来实现同步，使用方法如下：
在类中定义一个成员变量：Mutex mutex=new Mutex(false);//这里用false表示此刻还不希望锁定。
在使用时，可以这样：
mutex.WaitOne();
代码块
mutex.Close();

C#中用is代替Java中instanceof关键字。

C#中typeof和Type.GetType函数等同。

C#中的特性，首先它是一个派生于System.Attribute的类，而且在类命名的时候，通常都以Attribute结尾。定义一个特性就是普通的定义一个类。使用特性时，用一对中括号包含一个该特性定义的实例，然后放在方法前、类前、字段前即可。如：
我们定义了一个RegistryKeyAttribute的特性，然后使用时就可以：
[RegistryKey(34,"Foo")]//注意在引用时可以省略Attribute，系统会为其自动添加上
public int foo;
然后就可以检测该类的该属性是否具有RegistryKeyAttribute特性了。
C#中使用特性主要是为了添加注释，并把注释的信息捆绑到类上，在运行的时候就可以通过反射的机制来得到这些注释信息了，这点可以类比于Java中的Annotation。

C#中，可以使用名字隐藏(name hiding)技术，该技术主要应用于当一个类实现了某个接口时，如果我们用该类的一个实例来“点”一下的话，那么应该可以看到被实现的这个接口中的所有内容，为了不让外界看到接口中的内容，那么可以使用该技术。该技术使用的具体方法是在实现接口中的方法时去掉public关键字，改用接口名字代替。例如：本来应该是public void run(){}现在改为void Runnable.run(){}使用这种办法可以解决“同时实现多个接口时，当不同接口中存在同样的函数时，产生的名字模糊问题”，比如A和B接口都有fun方法，那么在一个类同时实现A和B接口时，可以这样写代码：void A.fun(){...}
void B.fun(){...}而在使用时，可以这样((A)类的一个对象).fun();这样调用的就是对接口A中fun方法的实现。

在C#中可以定义基于普通数值类型的enum类型，例如
enum Test : int
{
 One=1;
 Two,
 Three
};

C#中的switch语句中不允许“贯行<fall-through>”，即当一个case情况满足时，如果该case没有break语句，那么就会自动执行下一个case对应的语句，在C#中把贯行给取消了，而在java中还是保留了贯行的。

C#中也可以定义运算符重载，对于普通运算符重载时，相对于一般的函数定义，我们只需要把“函数名”替换为“operator<某运算符>”即可，例如：public static String operator+ (String s1,String s2)。比较特殊的是定义强制类型转换运算符，它的定义形式如下：
public static implicit operator conv-type-out (conv-type-in operand)
public static explicit operator conv-type-out (conv-type-in operand)
这里的implicit指“不需要客户端显式的给出，它会自动进行”；explicit指的是“客户端必须显式的指出需要转换的类型”。例如：
public static implicit operator float (String s)
最后，还需要提醒注意的是，对于运算符重载，必须都定义为public static，这一点必须保证。

类的成员包括：字段；方法：属性（智能字段）；常量；索引器（智能数组）；事件；操作符重载。

C#中对于类中定义的字段，如果前面不加限定符，则默认为private。

C#中和Java一样，对于字段或方法的定义，都是在每一个前面都要加限定符！

C#中多了一个internal限定符，表示该成员只在当前编译单元内可见，根据代码所在的位置，访问限定符“internal”代表了“public”和“protected”的访问性组合。

C#中调用基类的构造函数用base而不是super，而且调用位置也不同于Java，还是继承了C++的传统写法，如：
public B(int x) : base(x)

C#中readonly关键字和Java中的final差不多，都是定义常量用的，但是它定义的常量可以在构造函数内初始化，而const定义的常量只能在定义时初始化。如果再用static限定，那么也可以在static块中初始化。

C#中用限定符“sealed”来禁止一个类派生子类，和Java中的final关键字修饰一个类时的作用一样。

C#中用ref和out两个关键字来使得函数参数可以带回返回值。ref和C++中用“&”定义的引用一样，如：
public void change(ref int x,ref int y){
 int tmp=x;
 x=y;
 y=tmp;
}
在调用时也得change(ref x,ref y);但需要注意的是，x和y这两个变量必须被事先初始化。

使用out时，就不必初始化了，使用方法同ref。关键是要区别什么时候用ref什么时候用out。其实刚才在上面举的例子，一定要用ref，因为这个函数在处理时需要用到参数已有的值来交换，如果没有初始值，那还交换个什么劲儿啊，而如果我们只是希望通过函数调用带回来一些信息给我们使用，也就是想实现多返回值，仅仅出于此目的且函数处理中不必利用参数的初始值，那么就应该使用out。

C#中用“params”关键字来使得方法的参数个数可变，相当于在Java里定义函数时使用...效果一样。如：
public int sum(params int[] x)。但必须定义为数组类型。而在Java中这样就行：public int sum(int ... x)

C#中函数覆盖时，必须用关键字new来修饰，否则A.max()和B.max()各调用各自的，谁也不干涉谁（这里B派生自A）。

C#中要实现多态，必须在基类定义函数时用关键字virtual修饰，在子类中覆盖函数时用override修饰。而且被virtual修饰的基类函数还不能是private的，因为它对子类不可见。

C#中定义抽象类或抽象方法，也都是用abstract关键字声明，但是在子类实现时必须用override关键字修饰要实现的抽象函数。

C#中可以用foreach(int tmp in x)来实现类似Java中for(int tmp : x)的功能。

C#中用get和set关键字来得到、设置类的属性，这期间还会用到关键字value。举个例子如下：
protected string zipCode;
public string ZipCode
{
 get
 {
  return zipCode;
 }
 set
 {
  zipCode=value;
 }
}
这里ZipCode是一个属性名，可以随便起名字，但是为了和字段相匹配，我们给它起名为“ZipCode”。在使用时就得这样：
Address addr=new Address();
addr.ZipCode="55555";
string zip=addr.ZipCode;

C#中不能够在类中定义对象的时候就用new为其赋值！！！！！

C#中定义多维数组用int [, ,] x;多维数组得到某一维的长度用x.GetLength(第几维);查询多维数组的维数用x.Rank;

C#中用int [][] x;来定义二维的“锯齿状数组”，这同Java是一样的，这种锯齿状数组当然包括常规的二维数组了，但是在Java中并没有对它们进行区分。

================索引器================
简单说来，所谓索引器就是一类特殊的属性，通过它们你就可以像引用数组一样引用自己的类。
声明方法如下(与属性相似)：
//修饰符　类型名称 this [类型名称 参数名]
public type this [int index]
{
get
{
//...
}
set
{
//...
}
}
用例子简单说明：
using System.Collections;

static void Main(string[] args)
{
//调用IntBits.IntBits方法，意为将63赋给bits
IntBits bits = new IntBits(63);
//获得索引6的bool值，此时 bits[6]将调用索引器"public bool this[int index]"中的Get，值为True
bool peek = bits[6];
Console.WriteLine("bits[6] Value: {0}",peek);
bits[0] = true;
Console.WriteLine();

Console.ReadKey();
}

struct IntBits
{
private int bits;
public IntBits(int initialBitValue)
{
bits = initialBitValue;
Console.WriteLine(bits);
}
//定义索引器
//索引器的“属性名”是this，意思是回引类的当前实例，参数列表包含在方括号而非括号之内。
public bool this [int index]
{
get
{
return true;
}
set
{
if (value)
{
bits = 100;
}
}
}

备注:

所有索引器都使用this关键词来取代方法名。Class或Struct只允许定义一个索引器，而且总是命名为this。

索引器允许类或结构的实例按照与数组相同的方式进行索引。索引器类似于属性，不同之处在于它们的访问器采用参数。

get 访问器返回值。set 访问器分配值。

this 关键字用于定义索引器。

value 关键字用于定义由 set 索引器分配的值。

索引器不必根据整数值进行索引，由您决定如何定义特定的查找机制。

索引器可被重载。

索引器可以有多个形参，例如当访问二维数组时。

索引器可以使用百数值下标，而数组只能使用整数下标：如下列定义一个String下标的索引器
public int this [string name] {...}

属性和索引器

属性和索引器之间有好些差别：

类的每一个属性都必须拥有唯一的名称，而类里定义的每一个索引器都必须拥有唯一的签名（signature）或者参数列表（这样就可以实现索引器重载）。

属性可以是static（静态的）而索引器则必须是实例成员。

为索引器定义的访问函数可以访问传递给索引器的参数，而属性访问函数则没有参数。

不能用using指定类，但可以为类使用别名：
using alias=class

C#命名规范：
方法名使用第一个字符大写的Pascal规则；
变量名使用第一个字符小写的camel规则。

公共类型系统CTS(Common Type System)是在.NET中定义的类型标准，而且还支持用户自定义新的类型来进行类型的扩展。任何以.NET为平台的语言都必须建立该语言的数据类型到CTS类型之间的映射。所有.NET语言共享这一类型系统，实现各种语言之间的无缝的互操作。

装箱(boxing)与开箱(unboxing)：
装箱就是将数值类型转换为引用类型，此过程不需要显示转换。
如int foo=42;object bar=foo;
开箱就是将引用类型转换为数值类型，此过程必须显示转换。
如int foo2=(int)bar;
通过装箱与开箱使得C#中的一切开起来都是对象，但同时又避免了当所有一切都是真正的对象时对系统要求过高。

引用类型都是在堆上分配的。

⑴浅复制（浅克隆）
被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。另解：浅复制：两个或多个相同类型的指针指向相同的内存，也就是它们指向相同的数据，如果改变其中之一，其它的也将改变。
⑵深复制（深克隆）
被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。另解：深复制：将一个指针所指的数据复制给另外一个指针所指的内存，两个指针有自己的数据，如果改变一个，另外的不受影响。

.NET框架由基础类库BCL(Basic Class Library)和公共语言运行环境CLR(Common Language Runtime)两部分组成。BCL相当于MFC，来提供封装好的类库，该类库提供了从文件I/O、数据库到XML、SOAP等各个方面的支持；CLR可以类比JVM，来提供运行的平台。

在.NET框架中，出现了许多新的特性和功能，这些功能都是通过编译器对能够体现这些功能和特性的代码的编译来完成的，众所周知在.NET兼容了很多种语言，但是.NET编译器小组并没有为每种语言都设计了足够完整的对新特性的编译支持，他们只实现那些他们觉得对用户最有用的功能。但是，C#提供了访问几乎所有.NET框架功能的接口。

C#是一种与CLS标准兼容的语言，用C#编写出来的代码，经过编译，生成MSIL中间代码写入EXE文件，在运行时由JITer将MSIL代码编译为CPU识别的机器码，进而执行程序。