体验C#2.0的新特性

相对于ado.net2.0和asp.net2.0的变化，以及vs2005开发工具的大量的“傻瓜化”的改进来说，偶觉得C# 2.0的变化并不大。网上的相关资料还是蛮多的，偶把这个话题提出来，整理一些要点，并谈谈自己的体会，希望能起到一个抛砖引玉的作用，给还没有接触过C# 2.0的网友们一些引导，说得不好欢迎拍转~

C#2.0的变化有下面几个话题：
①泛型；
②匿名方法与迭代器；
③分部类型定义；
④“Nullable 泛型结构”；
⑤静态类；

其中最主要的是“泛型”，下面逐个讨论：
①泛型:

  为什么要引入泛型？
  举个例子比较好理解：例如定义一个System.Collection.ArrayList，里面的元素是object类型的，当从中取出的时候需要作强制类型转换ClassA tmp = myArrayList[0] as ClassA;这有两方面问题，一是强制类型转换的性能开销，二是类型安全(编译通过但是运行有可能出错)。在.net1.0中类似的情况是比较多的，引入泛型是为了较好地解决此问题。

所谓泛型，即通过参数化类型来实现在同一份代码上操作多种数据类型。泛型编程是一种编程范式，它利用“参数化类型”将类型抽象化，从而实现更为灵活的复用。
还是看看代码吧：
class Stack<T>
{
  private T[] store;
  private int size;
  public Stack()//构造函数
  {
    store = new T[10]; size=0;
  }
  public void Push(T tmp)
  {
    store[size++] = tmp;
  }
  public T Pop
  {
    return store[--size];
  }
}
上面就是一个泛型的实现，在实例化的时候该类的时候我们可以这样声名
Stack<int> aaa = new Stack<int>();
那么就约束了只能往这个堆栈里放int类型，例如aaa.Push(17);是可以的；
但是aaa.Push("123");编译就会不通过。

class C<U,V> {}   
class D: C<string,int> {}   
class E<U,V>: C<U, V> {}   
class F<U,V>: C<string, int> {}   

上面这些都是一些泛型的实现，这里就不一一解释了~
泛型还可以应用于接口和委托，实际编程时还有一些实际问题。
值得一提的是下面这个例子：(where)
class MyClass<S,T>
    where S: A     // S继承自A
    where T: B     // T继承自B
{......}

②匿名方法与迭代器；

匿名方法其实没什么，对比一下下面这两段代码就明白了：
（C# 1.0）:
Button1.click += new EventHandler(Button1_Click);
private void Button1_Click(object sender,EventArgs e)
{
       TextBox1.Text = "123";
}
有了匿名方法之后（C# 2.0）：
Button1.Click += delegate {
                  TextBox1.Text = "123";
}
关于匿名方法，老实说，偶认为只是为了可以省掉几行代码，比较方便地处理委托，属于C#编译器的“小花招”而已......

然后是“迭代器”：
在没有这个东东的时候如果需要创建一个集合(可用于foreach循环)，需要如此实现
Public class MyCollection : Ienumerable {
public MYEnumerator GetEnumerator(){
    return new MyEnumerator(this);
}
public class MyEnumerator : Ienumerator{
public void Reset(){ … }
public bool MoveNext(){ … }
public int Current{ … }
object IEnumerator.Current{ get{ … } }
     }
}
有了“迭代器”之后，这样就可以：
public class Stack<T>: IEnumerable<T>
{
       T[] items;
       int count;
       public void Push(T data) {…}
       public T Pop(){…}
       public Ienumerator<T> GetEnumerator(){
              for (int I = count – 1; i >=0;--i){
                              yield return items[i];
            }
}
比较简单，看看就能明白，有两个地方稍有点新鲜的：
1）增加了yield关键字；
2）使用迭代器创建倒序遍历：
Public Ienumerable<T> Bottom ToTop{
        get {
                     for(int I = 0;i < count; i++>){
                                   yield return items[i];
               }
    }}

③分部类型定义：

局部类型允许我们将一个类、结构或者接口分成几个部分，分别实现在几个不用的.cs文件中。当然，各个部分的命名空间是要相同的，访问保护修饰符也不能互相冲突。

为了实现这个东西，引入了半个关键字partial，之所以叫半个，是因为只有和class、struct、interface放在一起时，才有关键字的含义。

局部类型的实用意义偶倒是想到一个，就是我们有一些代码文件是通过某些工具生成的(例如用一些映射工具或者自己写的代码生成工作，去生成一些基本的实体类、数据访问类等)，这些代码文件我们又不希望跟手工增加的代码放在一起，就可以分开n个部分来放。

最后来段简单代码作为例子：
partial class MyClass
{
  public void test1()
  {....}
}

partial class MyClass
{
  public void test2()
  {....}
}
代码可以这样写，最终编译器还是会把各个部分编译到一起的，没有实质区别。

④“Nullable 泛型结构”

空属类型允许一个值类型具有“空值”意义，从而方便很多场合的运算，如数据库中的空字段。
楼上 lalac(水月流影)已经给了个例子：

int? a= null;
if(a == null)
{
  // a如果为空，则....;
}
else
{
  // a如果不为空，则....;
}

空属类型实际上是一个泛型类型System.Nullable<T> 。
 

⑤静态类：

问题真是一个比一个简单，静态类就是一个只包含静态成员的类。
例子
static class MyStaticClass
{
     public const int aaa;
     public static void Test1()
     {
       //……
     }
}

**************************************************************
说完了，总结一下，一句话：没什么太大意思~~~