C# 1

1.转移序列 @ 的用法：
  "C://TEMP//Mydir//Myfile.doc"
  应用@后：
  @"C:/TEMP/Mydir/Myfile.doc"
  唯一的例外就是 " ,必须用/"指定。

2.在switch中，C#只能执行一个case语句。不能像C++那样，在没遇到break之前，可以一次执行多个。

3.溢出检查环境：
  checked(expression) 检查是否溢出
desVar = checked((byte)sourceVar);
  unchecked(expression) 不检查是否溢出
  或者在VS中右击Solution explorer窗口中的项目，选择 properties，点击左边的build。
  点击advanced， 勾择 check for arithmetic overflow/underflow。默认是不检查的。

4.Convert.ToInt16(val);将val转换为INT16类型。
  Convert.*在System名称空间中，不是C#本身。并且他们总是进行溢出检查,所以Checked和unchecked关键字没用。

5.枚举类型转换
  枚举值转成字符串：ToString()
  字符串转成枚举值：(enumerationType)Enum.Parse(typeof(enumerationType), enumerationValueString);
  string myString = "north";
  orientation myDirection = (orientation)Enum.Parse(typeof(orientation), myString);

6.数组的声明
  int[] val = {1,2,3,4};
  int[,] val = {{1,2,3,4},{4,5,6,7},{5,6,7,1}};  声明了一个三行四列的二维数组。
  int[,,]声明三维数组。另一种声明方式：int[,,] val =new int[2,2,4];
  多维数组，可称为矩形数组，因为每一行的元素个数都相同。

  数组的数组，变长数组。
  int[][] = {new int[] {1},
    new int[] {1,2},
    new int[] {1,3,4}};
7.字符串处理
  string类型的变量可以看作是Char变量的“只读”数组,如下:
  string mystring = "A string";
  char myChar = myString[1];
 
  获得一个可写char数组的方法，如下：
  string myString = "A string";
  char[] myChars = myString.ToCharArray();

  «string».ToLower() & «string».ToUpper() 用来转换大小写。
  «string».Trim() & «string».TrimStart() & «string».TrimEnd()用来消除字符串中的空格。
  «string».PadLeft()&«string».PadRight():
  myString = "Aligned";   
  myString = myString.PadLeft(10); 在左边加3个空格,凑成10个字符
  myString = myString.padLeft(10,'-');在左边加3个“-”，凑成10个字符

  Split()方法
  string myString = "This is a test";
char[] separator = {' '};  如果有多个条件可以再次输入，如果遇到“a”分开，可以char[] separator = {' ','a'};
string[] myWords;
myWords = myString.Split(seperator);
foreach(string word in myWords)
{
 Console.WriteLine("{0}",word);
}
Console.ReadKey();
运行结果：
This
is
a
test
得到的每个单词没有空格。在使用split时，删除了分隔符。

8.C#参数数组，用params关键字定义
  如果有多个参数，这个参数必须是函数定义中的最后一个参数。实例如下：
static int SumVals(params int[] vals)
{
 int sum = 0;
 foreach(int val in vals)
  {
    sum+=val;
  }
 return sum;
}
调用方式：SumVals(1,5,2,9);
       
9.ref & out作函数参数。如：foo(ref int i) & foo(out int i)
ref 使用前“必须赋值”，离开函数时，可以修改也可以不修改。所以，ref 的参数不能声明为const。
   在调用函数是时也要加ref，如：foo(ref myNumber); ref是函数签名的一部分。
out 使用前不用赋值（赋值也没用，会被清空），离开函数时，必须被重新赋值。否则，会报错。
   调用方法参考ref

10. 委托 delegate
    委托使用三部曲：
    1. 声明
      delegate int ProcessDelegate(int param1, int param2);
     2. 委托变量
     ProcessDelegate Process；
     3. 绑定
     mutiply(int i, int j);
     Process = new ProcessDelegate(mutiply);
     4. 调用
     int result = Process(2,3);

11. IDisposable接口
     用于控制释放所示用的资源。

     支持IDisposable接口的对象必须实现其Dispose()方法。

    
    使用using关键字可以优化使用这个方法的结构，如：

    ClassName VariableName = new ClassName();

    ....

    using(VariableName)

    {
        ......

    }

    或者

    using(ClassName VariableName = new ClassName())

    {
        ......

    }

    这样，在using代码块中使用VariableName,并在代码块末尾自动删除（调用Dispose()）。

   

12. public pravite protected
    protected派生类可以访问，外部代码无法访问。

13. 虚拟、抽象、重写 (virtual & abstract & override «& extern» )
     ·i  抽象类可以有非抽象成员。并且抽象类的派生类可以为抽象类，且不用实现所有的抽象成员。非抽象派生类必须实现所有的抽象成员。
     ·ii 隐藏 与 重写
     重写虚方法的时候，会覆盖基类的原方法
     public class MyBaseClass
     {
            public virtual void DoSomething()
       { //Base Implementation.
            Console.WriteLine("Base imp");
       }
     }
 
    public class MyDerivedClass:MyBaseClass
     {
       public override void DoSomething()
       {    //Derived class implementation
            Console.WriteLine("Derived imp");
       }
     }
 
 当 MyDerivedClass myObj = new MyDerivedClass();
    MyBaseClass myBaseObj;
    MyBaseObj = myObj;
             myBaseObj.DoSomething();
         结果如下：
         Derived imp
--------------------------------------------
         隐藏基类方法时，仍然可以通过基类访问。也就是说，基类的方法被覆盖了。 
         可以用new关键字显示声明。也可以不用，隐式声明隐藏，但会显示warning。
 
            public class MyBaseClass   
            {
                public virtual void DoSomething()
                { //Base Implementation.
                    Console.WriteLine("Base imp");
                }
            }
 
         public class MyDerivedClass:MyBaseClass
         {
              new public void DoSomething()
              {
                    Console.WriteLine("Derived imp");
              }
         }
            结果如下：
            Base imp       
---------------------------------------------
        在派生类中，调用重写或隐藏的基类方法，base关键字。
        public class MyBaseClass
        {
             public virtual void DoSomething()
             {
             // Base implementation
             }
        }
        public class MyDerivedClass:MyBaseClass
        {
             public override void DoSomething()
             {   
                // Derived class implementation, extends base class implementation.
                   base.DoSomethig();
               // More derived class implementation
             }
       }
        注意：base使用的是对象实例，所以不能再静态成员中使用。
        this 关键字
        用法同上，该关键字引用对象实例。

14. 对象的包含关系
     用一个成员字段包含对象实例，就可以实现包含关系。

   

15. 创建事件（简单的例子）
MnewButton.Text = "New Button"; // 初始化属性
newButton.Click += new EventHandler(newButton_Click); // 绑定事件处理程序
        ......
private void newButton_Click(object sender, System.EventArgs e){....;};

16. internal 声明的类只能在当前项目中使用。P166

17. 构造函数的执行序列
    ·i public class MyBaseClass
{
  public MyBaseClass(){}
  public MyBaseClass(int i){}
}
-----------------
public class MyDerivedClass: MyBaseClass
{
  public MyDerivedClass()
  public MyDerivedClass(int i)
  public MyDerivedClass(int i, int j)
}
-------------------
  当MyDerivedClass myObj = new MyDerivedClass()时，System.Object.object()-»MyBaseClass.MyBaseClass()-»MyDerivedClass.MyDerivedClass()
当MyDerivedClass myObj = new MyDerivedClass(4)时，System.Object.object()-»MyBaseClass.MyBaseClass()-»MyDerivedClass.MyDerivedClass(4)
当MyDerivedClass myObj = new MyDerivedClass(4,8)时，System.Object.object()-»MyBaseClass.MyBaseClass()-»MyDerivedClass.MyDerivedClass(4,8)
    ·ii base关键字，如果
public class MyDerivedClass: MyBaseClass
{
  ........
  public MyDerivedClass(int i, int j):base(i)
}
那么，当MyDerivedClass myObj = new MyDerivedClass(4,8)时，System.Object.object()-»MyBaseClass.MyBaseClass(4)-»MyDerivedClass.MyDerivedClass(4,8)
public class MyDerivedClass: MyBaseClass
{
  ........
  public MyDerivedClass():base(5)
}
那么，当MyDerivedClass myObj = new MyDerivedClass()时，System.Object.object()-»MyBaseClass.MyBaseClass(i)-»MyDerivedClass.MyDerivedClass(4,8)
    ·iii this关键字，构造函数初始化器
public class MyDerivedClass: MyBaseClass
{
  public MyDerivedClass():this(5,6)
  ........
  public MyDerivedClass(int i, int j):base(i)
}
当MyDerivedClass myObj = new MyDerivedClass()时, System.Object.Object() -» MyBaseClass.MyBaseClass(int i) -» MyDerivedClass.MyDerivedClass(int i ,int j) -» MyDerivedClass.MyDerivedClass()

18. 类库项目
    类库项目没有程序入口点，所以，可以建一个新的应用程序（比如控制台程序），在引用（References）中添加引用(添加编译的类库项目-*.DLL)。

19. 接口
    在实现接口的类中，可以用关键字virtual 或 abstract来执行接口成员，但不能使用static 或 const。
    另外，接口成员还可以在基类中实现，如下：
   
    public interface IMyInterface
    {
       void DoSomething();
   void DoSomethingElse();
    }
    public class MyBaseClass
    {
     public void DoSomething()
{  }
    }
    public class MyDerivedClass:MyBaseClass,IMyInterface
    {
public void DoSomething()
{}  
    }
------------------------------------------
    基类实现的接口，意味着派生类隐式的支持这个接口，如下：
    public interface IMyInterface
    {
       void DoSomething();
   void DoSomethingElse();
    }
   
    public MyBaseClass:IMyInterface
    {
        public virtual void DoSomething()  {}
    }

    public class MyDerivedClass:MyBaseClass
    {
        public override void DoSomething() {}  //隐式支持基类继承的接口
    }
   
    如果派生类是隐藏 而不是 重写 接口, 则方法IMyInterface.DoSomething()总是引用基类版本，即使派生类用接口访问也是调用基类方法。
         ---------------------------------------------------------
    显示 及 隐式 执行 接口成员
public class MyClass: IMyInterface
{
   void IMyInterface.DoSomething() {} // 显示执行
   public void DoSomethingElse() {} // 隐式执行
}
       
        显示执行：
MyClass myObj = new MyClass();
IMyInterface myInt = myObj;
myInt.DoSomething();
        隐式执行：
        MyClass myObj = new MyClass();
myObj.DoSomethingElse();
只有隐式执行的DoSomethingElse()才可以用MyClass的对象实例直接访问
-------------------------------------------------------
    如果接口中有属性（有get和set访问器），在实现接口的类中，可以添加访问器，但添加的访问器的修饰符（如，public，protected...）,必须比接口中定义的更加严格才可以添加。
    public interface IMyInterface
    {
  int MyIntProperty
{
   get;
}
    }

    public class MyBaseClass: IMyInterface
    {
protected int myInt;
public int MyInterProperty
{
   get
{
   return myInt;
}
   protected set // 相比接口中多了set访问器，但访问修饰符为protected,比get的更加严格
{
   myInt = value;
}
}
    }

20. partial 关键字
部分类定义：
public partial class MyClass: IMyInterface1
{
.....
}
public partial class MyClass: IMyInterface2
{
.....
}
        以上两个和在一起等价于：

     public class MyClass:IMyInterface1, IMyInterface2
{
......
}
-----------------------------------
部分方法定义：
部分方法可以是static的，但总是private的，且 不能有返回值。使用的参数不能是out参数，可以是ref参数。不能使用virtual，abstract，override，new，sealed 和 extern。
执行编译时，如果代码包含一个没有执行代码的“部分方法”，会完全删除该方法，并且会删除对该方法的全部引用。
public partial class MyClass
{
partial void MyPartialMethod();   //有partial关键字
}
public partial class MyClass
{
partial void MyPartialMethod()  //有partial关键字
{
// method implementation
}
}

21. System.Collections名称空间中的几个接口
· IEnumerable 可以迭代集合中的项，该接口的唯一的方法为 GetEnumerable()可以迭代集合中的各项。实现该接口的类才能用foreach进行迭代。MSDN:http://msdn.microsoft.com/zh-cn/library/system.collections.ienumerable(VS.80).aspx
· ICollection （继承于IEnumerable）可以获取集合中项的个数，并能把项复制到一个简单的数组类型中
· IList（继承于IEnumerable 和 ICollection）提供了几个的项列表，并可以访问这些项，以及其他一些与项列表相关的功能
· IDictionary（继承于IEnumerable 和 ICollection）类似于IList，但提供了可以通过“键码值”而不是“索引”访问的项列表
System.Array类实现了IList、ICollection和 IEnumerable，但不支持IList的一些更高级的功能。它表示大小固定的项列表
System.ArrayList类实现了IList、ICollection和 IEnumerable,可以表示大小可变的项列表。
   Arraylist集合可以用AddRange()添加好几个项。这个方法接受带有ICollection接口的任何对象。但该方法不是任何借口的一部分，是ArrayList专有的。
   IList的IndexOf()返回找到对象的索引；如果某对象在列表中出现多次，则 IndexOf 方法将始终返回找到的第一个实例。
  
22. 定义集合-应用System.Collections.CollectionBase抽象类
CollectionBase类有接口 IEnumerable, ICollection 和 IList，但只提供了一些要求的代码。
CollectionBase提供了两个受保护的属性 List 和 InnerList，List可以通过IList接口访问项，InnerList则是用于存储项的ArrayList对象。
例1.
public class Animals : CollectionBase
{
   public void Add(Animal newAnimal)
   {
List.Add(newAnimal); // 利用List属性操作集合中的项
            }
   public void Remove(Animal oldAnimal)
   {
List.Remove(oldAnimal);    // 利用List属性操作集合中的项
   }
   public Animals()
   {}
}
结论：IList的Add() 和 Remove()方法为强类型话的方法。在本例中只能处理Animal类 或 派生于Animal的类。而前面介绍的ArrayList执行代码可以处理任何对象。
例2.
Animals animalCollection = new Animals();
animalCollection.Add(new Cow("Sarah"));
foreach(Animal in animalCollection)
{
   ........
}
结论：CollectionBase类可以对派生类的集合使用foreach语法
---------------------------------------------
CollectionBase的索引符

public class Animals: CollectionBase
{
   ....
 public Animal this[int animalIndex]
 {
       get
{
   return (Animal)List[animalIndex];   // 因为IList.List属性返回的是一个System.Object对象，所以需要进行显示类型转换
}
    set
{
   List[animalIndex] = value; // List使用索引符，在IList上，访问CollectionBase中的ArrayList.
}
 }
}
然后就可以使用：
animalCollection[0].Feed()
否则，只能用 ((Animal)animalCollection[0]).Feed();
------------------------------------------------------------
23. 定义关键字集合--应用System.Collections.DictionaryBase抽象基类
    DictionaryBase实现IEnumerable 和ICollection接口。 DictionaryBase简化了IDictionary接口的实现。
   
例1：
public class Animals: DictionaryBase
{
 public void Add(string newID, Animal newAnimal)
 {
Dictionary.Add(newID, newAnimal);  //利用Dictionary访问集合项
 }
 
 public void Remove(string animalID)
 {
  Dictionary.Remove(newID);
 }
 public Animals() {}
 public Animal this[string animalID]
 {
  get
{
 return (Animal)Dictionary(animalID);
}
set
{
 Dictionary[animalID] = value;
}
 }
}
--------------------
foreach工作方式
DictionaryBase需要用 System.Collections.DictionaryEntry结构. 要得到DictionaryBase派生类对象本身（比如，Animal对象本身），就必须使用这个结构的Value成员，也可以使用Key成员得到相关的关键字。
foreach (DictionaryEntry myEntry in animalCollection)    //animalCollection是 Dictionary派生类的对象
{
  Console.WriteLine("{0} AND {1}", myEntry.Value.ToString(),((Animal)myEntry.Value).Name);   //也可以用迭代器实现如下的代码，具体见下一条目。
}
想等价的代码：
  foreach (Animal myAnimal in animalCollection) // animalCollection是CollectionBase派生类的对象
{
  Console.WriteLine("{0} AND {1}", myAnimal.ToString(),myAnimal.Name());
}

24. 迭代器
·如果要迭代一个类，可使用GetEnumerator()，其返回类型是IEnumerable。
·如果要迭代一个类成员，例如一个方法，则使用IEnumerable。

迭代类成员（方法）：
public static IEnumerable SimpleList()
{
  yield return "string 1";
  yield return "string 2";
  yield return "string 3";
}

public static void Main(string[] args)
{
   foreach (string item in SimpleList())
Console.WriteLine(item);
   Console.ReadyKey();
}

运行结果为：
string 1
string 2
string 3

可以用" yield break; " 中断信息返回
----------------------------
迭代类：
public class Primes
{
   private long min;
   private long max;
  
   public Primes() : this(2,100) {...}
   public Primes(long minimum, long maximum) {...}
  
   public IEnumerator GetEnumerator()
{  ....
  if(...)
  yield return possiblePrime;
}
}

static void Main(string[] args)
{
   Primes primesFrom2To1000 = new Primes(2,1000);
   foreach (long i in primesFrom2To1000)    // 因为类Primes实现了GetEnumerator方法，所以可以迭代。
{ Console.Write("{0}",i); }
   Console.ReadyKey();
}
-------------------------------------------------
迭代器和DictionaryBase集合
public class Animals: DictionaryBase
{
 public void Add(string newID, Animal newAnimal) {Dictionary.Add(newID, newAnimal);}
 public void Remove(string animalID) {Dictionary.Remove(animalID);}
 public Animals() {...}
          public Animal this[string animalID]
 {
    get
{
 return (Animal)Dictionary[animalID];
}
    set
{
 Dictionary[animalID] = value;
}
 }

 // 添加迭代器
 public new IEnumerator GetEnumerator()
 {
    foreach (object animal in Dictonary.Values)
yield return (Animal)animal;
 }
}
        接下来就可以在迭代集合中使用Animal对象了
foreach(Animal myAnimal in animalCollection)
  Console.WriteLine("{0} AND {1}", myAnimal.ToString(),myAnimal.Name);
25. 浅度复制 与 深度复制
    ·i 浅度复制
利用受保护(protected)的方法 System.Object.MemberwiseClone()，无参数，返回对象类型。
例：
public class Cloner
{
   public int Val;
   public Cloner(int newVal) { Val = newVal;} // 构造函数
  
   public object GetCopy()
   {
return MemberwiseClone();// MemberwiseClone() 对当前对象执行浅度复制。
   }
}
局限：当类中有引用类型时，浅度复制得到的对象，所以用的部分与源对象相同。
   
    ·ii 深度复制
类要求实现接口 ICloneable，该接口有一个Clone()方法，无参数，返回对象类型。
public class Content
{
   public int Val;
}
public class Cloner: ICloneable
{
   public Content MyContent = new Content();
   public Cloner(int newval) { MyContent.Val = newVal; }
  
   public object Clone() //实现Clone方法，实现深度复制
   {
Cloner clonedCloner = new Cloner(MyContent.Val);
       return clonerCloner;
   }
         }

注意：深度复制的代码( Clone() )是要自己编写的。
      Clone()是一个递归过程：
               上例中Content类中没有引用类型，所以，可只对Cloner()深度复制。
      如果，Content中有引用类型就需要如下代码：
public object Clone()
{
   Cloner clonedCloner = new Cloner();
   clonedCloner.MyContent = MyContent.Clone();
   return clonedCloner;
}

26. 封箱 & 拆箱
    封箱(boxing)，  值类型 -» System.Object 类型 || 转换为值类型实现的接口类型
    拆箱(unboxing)，相反过程。
 
    struct MyStruct
    { public int Val;   }

    MyStruct valType1 = new MyStruct();
    object refType = valType1;    // 封箱
......
    MyStruct valType2 = (MyStruct)refType; // 拆箱
----------------
    Struct Mystruct: IMyInterface
    {......}

    Mystruct valType2 = new MyStruct();
    IMyInterface refType = valType2;     // 封箱到接口对象中
    由以上，可知，封箱是隐式的（不需要显示转换），而拆箱是显示的（需要显示转换）

27. is 运算符
    «operand» is «type»
    ·如果 «type» 是一个类， «operand» 也是该类型，或继承了该类，或封封箱到该类型， 结果为TRUE。
    ·如果 «type» 是一个接口，«operand» 也是该类型，或实现了该接口，结果为TRUE。
    ·如果 «type» 是一个值类型，«operand»也是该类型，或被拆箱到该类型中，结果为TRUE。

28. 运算符重载
    public class ClassA
    {
public int Val;
 
public static ClassA operator +(ClassA op1, ClassA op2)  运算符重载声明格式，如果是一元运算符，那就只有一个参数。
{
   ClassA returnVal = new ClassA();
   returnVal.Val = op1.Val + op2.Val;
   return returnVal;
}
    }

    ClassA  op1,op2,op3;  ......
    op3 = op1 + op2;    
    ----------------------------------
    混合类型操作符：
    ......
    public static ClassC operator +(ClassA op1, ClassB op2 )
    {
ClassC returnVal = new ClassC();
returnVal.Val = op1.Val + op2.Val;
return returnVal;
    }
    ......
    混合类型操作符重载注意：
    不要把 签名相同的运算符 添加到 多个类中。因为程序不知道该调用哪个运算符。
     比如：如果ClassB也定义了上面的操作符，代码就会失败。
    另外，操作数的顺序 和 运算符重载的 顺序 要 相同。
    ClassA op1 = new ClassA();
    ClassB op2 = new ClassB();
    ClassC op3 = op2 + op1;  // 该代码会出错，因为重载运算符中定义的是 (ClassA op1, ClassB op2), 先ClassA 后 ClassB的顺序。
    ----------------------------------
    可以重载的运算符：
    ·一元: +, -, !, ++, --, true, false
    ·二元: +, -, *, /, %, &, |, ^, ««, »»
    ·比较: ==, !=, «, », «=, »=

    "+=" 不能重载，但重载 "+" 相当于重载 "+="
    "«" 和 "»"  以及 "«=" 和 "»=" 需要成对重载
    重载true 和 false后，就可以在布尔表达式中使用类，如 if(op1) {....}。
    重载"==" 和 "!="时，最好也重写Object.Equals() 和 Object.GetHashCode()。
   public override bool Equals(Object op1) {......}  //注意,参数是Object类型
public override int GetHashCode() {......}

29. IComparable 和 IComparer 接口
    可以使用这两个接口对 集合排序。
      ·IComparable 在要比较的对象的类中实现，提供了CompareTo(..)方法，可比较该对象，和另一个对象。
      ·ICompare 在一个单独的类中实现，提供了Compare()方法，可比较任意两个对象。
     一般，用IComparable给出类的默认比较代码，用实现ICompare的其他类给出非默认比较代码。
   
   类Compare在System.Collections名称空间中，提供了ICompare接口的默认实现方式。可以使用Compare.Default静态成员，接着使用Compare()方法。比如，Compare.Default.Compare(«T» x, «T» y)。
     Compare类的注意事项：
·检查传给Compare()的对象是否支持 IComparable。如果支持，就是用对象类的代码。
·null 小于 其他对象。
·字符串根据当前“特定区域性的信息”（非托管代码称为“区域设置”）处理。要使用不同的“区域信息”，Compare类必须实例化，以便传送System.Globalization.CultureInfo对象。
·字符串处理时区分大小写。要不区分大小写，需要用CaseInsensitiveComparer类。
   
    System.Collections名称空间中的一些类没有排序方法，比如，CollectionBase类。  而ArrayList的Sort()方法，只有在ArrayList中填充简单类型时，才能进行排序。对于自己定义的类，必须在类中实现IComparable或是创建一个类实现ICompare类，来进行比较。
     下面，分别用 IComparable 和 ICompare来实现自定义类型的排序:

class Person: IComparable
{
   public string Name;
   public int Age;
     public Person(string name, int age) {.....}
     
   public CompareTo(Object obj)    // 当Person的ArrayList进行Sort()排序时，会调用该函数实现排序功能。
   {
if(obj is Person)
{
  Person otherPerson = obj as Person;
  return this.Age - otherPerson.Age;
}
else
{
  throw new ArgumentException( "......" )
}
      }
}    
       -----------
public class PersonCompareName: ICompare
{
  public static ICompare Default = new PersonCompareName();
  public int Compare(Object x, Object y)
  {
      if(x is Person && y is Person)
{
   return Compare.Default.Compare(
((Person)x).Name, ((Person)y).Name );
               else
  throw new ArgumentException(".......");
}
  }
}
-----------

static void Main()
{
   ArrayList list = new ArrayList();
            list.Add(new Person("Jim",30));
.....
            list.Add(new Person("Bob",22));
            list.Sort();   // 因Person类实现了IComparable接口，所以，Sort()调用CompareTo(Object obj)方法进行排序。
            list.Sort(PersonCompareName.Default); // 调用其他实现ICompare的类（PersonCompareName），调用Compare()方法进行排序。
}

30. 转换
    · 重载转换运算符
在不相关的类型之间转换时，需要定义 显示 或 隐式 转换：
public class ConvClass1
{
  public int val;
 
  public static implicit operator ConvClass2(ConvClass1)  // 定义 ConvClass1到ConvClass2的隐士转换
  {
ConvClass2 returnVal = new ConvClass2();
returnVal.val = op1.val;
                return returnVal;
  }
}

public class ConvClass2
{
  public double val;
           public static explicit operator ConvClass1(ConvClass2 op1)
  {
ConvClass1 returnVal = new ConvClass1();
  checked (returnVal.val) = (int)op1.val;
return returnVal;
           }
}

ConvClass1 op1 = new ConvClass1();
ConvClass2 op2 = new ConvClass2();
.....
op2 = op1;  //根据定义，可以隐士转换
op1 = (ConvClass1)op2;  //根据定义，需要显示转换
  ---------------------------------------
    · as 转换为指定的引用类型
       «operand» as «type»
·«operand» 的类型是«type»类型
·«operand» 可以隐式转换为«type»类型
·«operand» 可以封箱到«type»类型中
如果不能转换，则表达式返回 null。返回null而不是异常，比较好处理。

31. 可空类型 System.Nullable«T»
    ·声明可空的值类型。
      System.Nullable«int» nullableInt;
      nullableInt = null;  //因为int类型为值类型，如果nullableInt不是可空类型，那么它不能用null赋值。
      .......
      if (nullableInt == null) {......}//可以像测试引用类型一样，测试可空类型，看它是否为null
 
      另外，还可以使用HasValue属性:
      if( nullableInt.HasValue ) {.......} //引用类型不能用HasValue属性，会抛出异常。因为，引用类型的null，表示没有对象，当然就不能通过对象访问。
      ------------------
      另一种，声明可空类型的语法：
      int? nullableInt;  // int?是System.Nullable«int» 的缩写。 
   
    ·运算符 和 可空类型
      int? op1 = 5;
      int? result = op1*2;   // 可以运算
      ******
      int result = op1*2;   // 不能编译
      ******
      int result = (int) op1*2; //可以编译并运算，但当op1为null时，会抛出System.InvalidOperationException异常。
     
      当可空类型进行运算时，如果有操作数为null, 除bool?之外的简单可控类型，运算结果是null。解释为不能运算。
      对于bool?, 如果不需要值为null的操作数就能算出结果，那么就可以运算；如果需要，结果就为null。比如：true|null 结果为true（只要有true，结果就为ture）， false|null结果为null（第一个操作数为false，所以需要另一个值来运算，所以结果为null）。
      ----------------------
     ·??运算符
       op1??op2;
       等效于：
       op1==null ? op2:op1;

32. 泛型 System.Collections.Generic
    这个名称空间中包含处理集合的泛型类型。
    ·List«T»
      成员: Count, Add(T item), AddRange(IEnumerable«t»), AsReadOnly(), Capacity, Clear(), Contains(T item), CopyTo(T[] array, int index), GetEnumerator(), IndexOf(T item), Insert(int index, T item), Remove(T item), RemoveAt(int index), Item....
      例：
Animals animalCollection = new Animals();   //Animals继承了CollectionBase。
     可替换为：
List«Animal» animalCollection = new List«Animal»();
  另一种修改方法为：  
  public class Animals : List«Animal» {.......}  //该方法，可以在集合类Animals中添加额外的成员。

CollectionBase类的用途：1. 向后兼容。2.更多的控制向类的“用户”展示的成员。比如，将集合的Add()方法，使用内部访问修饰符。
      -------------------------
     ·对泛型列表 的 排序 和 搜索
       对List«T»排序的两个方法：
       1. 在需要的类上提供IComparable«T» 或  提供 ICompare«T»接口
       2. 提供泛型委托作为排序方法
 排序 和 搜索 的泛型委托：
 ·Comparison«T» : 这个委托类型用于排序方法，器返回类型 和 参数 是 int method (T objectA, T objectB).
 ·Predicate«T» : 这个委托类型用于搜索方法，其返回类型 和 参数是 bool method(T targetObject).
       例：
 public class Vectors : List«Vector»
 {
    public Vectors() {....}
    public Vectors(IEnumerable«Vectors» initialItems)
    {
foreach (Vector vector in initialItem)
{
   Add(vector);
}
             }
    ......
 }
        添加一个新类VectorDelegates，用于提供泛型委托所用的方法
 public static class VctorDelegates
 {
    public static int Compare(Vector x, Vector y)  //排序方法
    {
if(x.R » y.R)
{
  return 1;
}
else if(x.R « y.R )
    {
return -1;
            }
return 0;
  
    }
    public static bool TopRightQuadrant(Vector target)  //用于搜索
    {
if(target.Theta =» 0.0 && target.Theta«= 90.0)
{
  return true;
}
else
{
  return false;
}
             }
 }
 
 在主程序中 应用 排序 和 搜索 方法：
 static void Main(string[] args)
 {
    Vectors route = new Vectors();
             route.Add(new Vector(2.0, 90.0));
.....
    Comparison«Vector» sorter = new Comparison«Vector»(VectorDelegates.Compare); //绑定委托
             route.Sort(sorter); //完成排序
.....
    Predicate«Vector» searcher = new Predicate«Vector»(VectorDelegates.TopRightQuadrant); //绑定委托
    Vectors topRightQuadrantRoute = new Vectors(route.FindAll(searcher)); // 完成搜索
  .....    
 }
 
33. Dictionary«K,V»
    ·可以使用Keys 和 Values 属性迭代集合中的 键和值。
Dictionary«string ,int» thing = new Dictionary«string, int»();
        foreach (string key in thing.Keys)  //用Keys属性迭代
{......}

foreach (string value in thing.Values) //用Values属性迭代
{......}
        ---------------
     可以迭代集合中的项，用KeyValuePair«K,V»实例来获取（与DictionaryEntry对象相同）
foreach(KeyValuePair«string, int» thing in things)
{.......}
   
   ·使用不区分大小写的方法来比较字符串
Dictionary«string, int» things = new Dictionary«string, int»(StringCompare.CurrentCultureIgonreCase);
此时，如果执行下面的操作，会抛出ArgumentException异常
things.Add("GREEN", 29);
things.Add("green",94);  //因为不区分大小写，以上两个实例拥有相同的键值，所以会异常。

34.泛型
    定义泛型类

         无绑定类型：

            class MyGenericClass«T» {.......}

            class MyGenericClass«T1,T2,T3» {.......}

            class MyGenericClass«T1,T2,T3»

                {
                    private T1 innerT1Object;

                    public MyGenericClass(T1 item)  {innerT1Object = item;}

                    // innerT1Object = new T1();     //这行代码不能编译通过，因为不能假定T1是什么类型。
                                                                //不知道T1是什么也就不能使用它的构造函数（因为T1可能没有可公共访问的构造函数）。

                    .....

                }

           default关键字：
            public MyGenericClass()
            { innerT1Object = default(T1);  }    //不能赋给innerT1Object的值为null，因它可能是值类型。
                                                            //所以用default，会赋给innerT1Object合适的默认值，比如，引用型赋值为null，整型赋值为0等等。
      

        约束类型：

            ? 疑问-»P282中，为什么MyGenericClass«Cow» = new  MyGenericClass«Cow»是可以编译的？

            where关键字：
            class MyGenericClass«T» where T: constraint1, constraint2   {...........}

            // 其中constraint1 & constraint2为约束条件。 可以n个约束条件，用逗号分开。

           class MyGenericClass«T1, T2» where T1: constraint1 where T2: constraint2

            // 也可以用多个where约束

           class MygenericClass«T1,T2» : MyBaseClass, IMyInterface where T1: constaint1 where T2: constaint2 {........}

           // 约束要在继承说明符后面

           
           class MyGenericClass«T1,T2» where T2:T1 {...}  //这称为“裸类型约束”，一个泛型 做 另一个泛型的约束。 但不能循环，如：...where T2: T1 where T1:T2

           一些可用的约束：struct, class, base-class, interface, new() 见书P283 表 12-5 。如果new()作约束，它必须是最后一个约束。

        例：
            public abstract class Animal  {......}  

            public class Chicken : Animal {......}

            public class Cow: Animal {....}

            public class SuperCow : Cow {......}

            public class Farm«T» : IEnumerable«T» where T :Animal

            {
                private List«T» animals = new List«T» ();

                public List«T» Animals { set { return animals;} }

               

                public IEnumerator«T» GetEnumerator() {return animals.GetEnumerator();}      //实现了IEnumerable«T»接口，这样，Farm«T»可以直接迭代（如：foreach(Cow cow in    
                                                                                                                          //Farm«Cow»)），不需要用Farm«T».Animals(如：foreach (Animal animal in Farm«T».Animals ))。

                IEnumerator IEnumerable.GetEnumerator() {return animals.GetEnumerator();}   //另一方面，因为IEnumerable«T»继承自IEnumerable，所以还需要实现IEnumerable

                .......

            }

       

           

         从泛型类中继承：

             class SuperFarm«T» : Farm«T» where T:SuperCow {.....}  //Farm«T»中T被约束为Animal，而SuperCow为Animals的子集，所以可以约束。
                                                                                            //如果SuperCow换成 struct（因为T 不能转换为Farm«T»中的T） 或 class（是 T 的超集）就不能编译。

                                                                                            //结论: SuperFarm«T»继承 Farm«T»，所以，SuperFarm«T» 至少要受到 Farm«T»所受到的约束。

            

             public class Cards: List«Card» ,ICloneable {...} // 继承一个泛型类，必须提供所有必须信息。
                                                                             // 如果，List«Card»换成 List«T»那么编译会失败。

        泛型运算符:

            隐式转换运算符：

                public static implicit operator List«Animal» (Farm«T» farm)

                    {
                        List«Animal» result = new List«Animal»();

                        foreach (T animal in farm)

                        {
                            result.Add(animal);

                        }

                        return result;

                    }   

            重载运算符：

                public static Farm«T» operator + (Farm«T» farm1, List«T» farm2)

                {
                    Farm«T» result = new Farm«T»();

                    foreach (T animal in farm1)
                    {
                        result.Animals.Add(animal);

                    }

                    foreach ( T animal in farm2)

                    {
                        if (!result.Animals.Contains(animal)) { result.Animals.Add();}                      
                    }                   
                    return result;

                }
                public static Farm«T» operator +(List«T» farm1 , Farm«T» farm2) {return farm2 + farm1;}  // 注意 “重载+” 时的参数， 第一个是 Farm«T»+ List«T», 第二个是List«T»+ Farm«T»
            --------------------------------

            另一种方法：

                public static Farm«T» operator +(Farm«T» farm1, Farm«T» farm2) {..............}

                public static implicit operator Farm«Animal» (Farm«T» farm) {........}      

                //隐式转换，将对象转换为Farm«Animal»类型，然后，可以利用重载的 “+” 进行运算。

       
    定义泛型方法：

        非泛型类的 泛型方法：

            public class Defaulter

            {
                public T GetDefault«T» () {.....}

            }

         泛型类的 泛型方法：

            public class Defaulter«T»

            {
                public T GetDefault«T1»(){........}     //  T1 和 T 不能相同，否则编译失败。

            }

        泛型方法的重载：

        public void ProcessT«T» (T op1) {.......}

        public void ProcessT«T, U» (T op1, U op2) {.......}

        使用哪个方法，取决于 参数 的个数。

35. ::运算符 & 全局名称空间限定
       :: 用于别名访问

        using MyAlias = MyRootSpace.Myspace;      // 设定 别名 MyAlias

        namespace MyRootNamespace

        {
            namespace MyAlias                             // 写一个与 别名 相同的 命名空间

            {
                public class MyClass {.........}     

            }

            namespace Myspace                          // 这个是设定到 “别名” -MyAlias 的 命名空间

            {
                public class MyClass {.........}

            }

        }

        ************

        //应用方式

        MyAlias.MyClass  引用的是   MyAlias命名空间的 类

        MyAlias::MyClass  引用的是   Myspace 命名空间的 类

            ---------------------------------------------------------------------

        :: 还经常 和 global 关键字 一起使用

         global是 “顶级根名称空间” 的 别名
         global::System.Collections.Generic.List«int»

         在大项目中才会出现，防止名称空间重名造成的引用混乱。

36. 定制异常
    异常的基类：System.Exception 和 System.ApplicationException

        System.SystemExceptiron用于.NET Framework预定义的异常的基类。

        System.ApplicationException由开发人员用于派生自己的异常类。

        这两个基类派生于Exception,但都没有扩展Exception类的功能。可以继承Exceptiron进行定制，但最好通过分类，继承上面两个基类。有助于分清是那种异常。
       

        例：

        public class CardOutOfRangeExceptiron:Exception    //定制异常类
        {
            private Cards deckContents;

            public Cards DeckContents{ get {return deckContents;}}

            public CardOutOfRangeExceptrion(Cards sourceDeckContents) : base("There are only 52 cards in the deck.")  {deckContents = sourceDeckContents;}

        }

       
        //******* 在方法中使用定制异常**********

        public Card GetCard(int cardNum)

        {
            if (cardNum »= 0 && cardNum «= 51 )

                return cards[cardNum];

            else
                throw new CardOutOfRangeException(cards.Clone() as Cards);

        }

        //********测试************

        Deck deckTest = new Deck();

        try{ Card myCard = deckTest.GetCard(60);}  //GetCard(60)中60超出范围，引发异常

        catch （CardOutOfRangeException e） 
        {
            Console.WriteLine(e.Message);                 // 抛出在定制异常时，用基类初始化的提示（e.Message）          

            Console.WriteLine(e.DeckContents[0]);      // 通过定制异常，获取对象（e.DeckContents[0]）。

        }

        //*******输出结果：**********    
        There are only 52 cards in the deck.  

        The ace of clubs                              

36. 事件
    自定义事件：

        public delegate void MessageHandler(string messageText);      // 第一步： 定义委托类型
        ......
        public class Connection
        {
            public event MessageHandler MessageArrived;        // 第二步： 声明事件。 用event关键字 和 要使用的委托类型 MessageHandler。

            .......

            private void CheckForMessage(object source, MessageEventArgs e)

            {
                ....

                if(MessageArrived != null)                // 判断MessageArrived是否有引用事件处理程序。用+=订阅事件（把事件与处理程序关联起来) 。

                {  MessageArrived("Hello Mum!"); }                 // 第三步： 引发事件。 （此例中，是在 另一个事件处理程序中进行引用）
            }            
        }

    *********订阅事件**********

        public class Display

        {
            public void DisplayMessage(string message) { Console.WriteLine("Message arrived: {0}", message );}        //定义事件处理程序

        }

         static void Main(string[] args)

        {
            ........   

            Connection myCon = new Connection();

            Display myDisplay = new Display();

            mycon.MessageArrived += new MessageHandler(myDisplay.DisplayMessage);      // 用+=订阅事件。 MessageArrived为前面声明的事件；
                                                                                                                       //MessageHandler为前面定义的委托类型；

                                                                                                                       //DisplayMessage为定义的事件处理程序，与 委托MessageHandler的签名相同。

            ........    
        }

        ---------------------------------------------------------------------------------

    事件的参数：

        前面 例子中的 委托 包含了事件处理程序中常见的两个参数： object source & MessageEventArgs e。

            这两个参数可以在定义委托时自己定义，比如： public delegate void MessageHandler(Connection source, MessageArrivedEventArgs e);   //Connection为前面定义的类

       

        自定义事件参数:

            public class MessageArrivedEventArgs : EventArgs               // System.EventArgs

            {
                private string message;

                public string Message {get { return message;}}

                public MessageArrivedEventArgs() {.......}
                ..........

            }

        利用派生于 System.EventArgs类的参数，可以提供更多的必要信息。另外，还可以实现参数的多态性。如下：
            Console.WriteLine( ( (MessageArrivedArgs)e ).Message );

       ---------------------------------------------------------------------------------
    返回值 和 事件处理程序：

        推使用 void 类型的事件处理程序，且避免使用out类型参数。

        但如果事件处理程序有返回类型，那么当调用好几个事件处理程序时，返回最后一个订阅的事件处理程序返回的值。
          --------------------------------------------------------------------------------

    匿名方法：

        匿名方法不是某个类上的 方法，而纯粹是为用作委托目的而创建的。

        创建匿名方法的代码：

        delegate(parameters)

        {          
            // 匿名方法代码

        };   //注意这里有个分号！！

        例：

            myConnection.MessageArrived += deleage(Connection source, MessageArrivedEventArgs e) { Console.WriteLine(source.Name);......};

=================================================================================================================================
C# 3.0部分

38.自动属性 和 部分方法
   自动属性： public string Name{get;set;}

39.初始化器
    初始化器会首先调用默认初始化函数，如没有，有时候编译器会自动提供一个。有时则必须提供一个。

    对象初始化器：

        例：

            public class Curry    // 定义一个类

            {
                public string MainIngredient {get; set;}

                public string Style {get; set;}

                public int Spiciness{get; set;}

                ......

            }

            *************************

            Curry testCurry = new Curry

            {
                MainIngredient = "panir tikka",         // 初始化时，各个参数用","分隔

                Style = "jalfrezi",

                Spiciess = 8

            };       //注意有分号，可以把代码写在一行

        ********************************

         如果，类型比较复杂，初始化器可以进行嵌套：

            Curry testCurry = new Curry

            {
                MainIngredient = "panir tikka",

                ......

                Orign = new Restaurant { name = "King's Balti", Location = "York Road",.....};

            };

    集合初始化器(常常会与LINQ技术一起使用)：

        例：

            List«Curry» moreCurries = new List«Curry»

            {
                new Curry { MainIngredient = "Chicken", Style = "Pathia", Spiciness = 6 },

                new Curry { MainIngredient = "Vegetable", Style = "Korma", Spicines = 3 },

                new Curry { MainIngredient = "Prawn", Style = "Vindaloo", Spiciness = 9}

            };

            可以代替：
            List«Curry» curries = new List«Curry»();

            curries.Add(new Curry("Chicken","Pathia",6));           

            ......

            curries.Add(new Curry("Prawn","Vindaloo",9));

      ***************************
            public class Animal {.............}

            public class Cow:Animal {......}

            public class Chicken:Animal {.......}

            public class SuperCow:Animal {......}

           

            static void Main(string[] Args)    
            {
                Farm«Animal» farm = new Farm«Animal»

                {
                    new Cow {Name = "Norris"},   

                    new Chicken {Name = "Rita"},

                    new Chicken();

                    new SuperCow{ Name = "Chesney"}

                };

                 ................

            }

            要是上面的初始化器能够有效需要做以下两件事：

            ·i 给派生于Animal的类添加默认构造函数。Name属性可以利用基类的默认构造函数初始化。 public Animal（）{name = “the animal is no name” ;}

            ·ii 为Farm«T» 添加Add方法：

                public Farm«T» : IEnumerable«T» where T: Animal

                {
                     public void Add(T animal)  {  animal.Add(animal);}    // 添加Add方法
                }

                因为编译器在集合初始化器中要为提供的每一项调用Add()方法。在上面的初始化器中编译器猜不出是要用Animal.Add（）填充属性，所以要在Farm«T»中添加Add方法。

                也可以用下面的方法初始化：

                Farm«Animal» farm = new Farm«Animal»

                {
                    Animal =                                                     // 这样就不需要为Farm类添加Add()方法了

                    {
                        new Cow {Name = "Norris"},    
                        new Chicken {Name = "Rita"},

                        new Chicken();

                        new SuperCow{ Name = "Chesney"}
                    }
                };

           

40. 推断类型 var
    var并不是声明了一个没有类型的变量（C#是强类型化的语言）。
    在用var生命变量时，必须同时初始化该变量，以便让编译器确定变量类型。如果编译器不能确定，就不能编译。

    比如:

            var myVar = 5; // 此时，myVar被确定为int型。

            var myArray = new[] {4,5,2};

            在隐式指定数组类型时，初始化器中使用的数组元素必须是：

            ·相同的类型

            ·相同的引用类型 或 空

            ·所以元素的类型都可以隐式的转换为一个类型

   

    总之，如果如能确定var变量的类型，编译就无法通过。

41. 匿名类型
    常常有一些类只是提供属性。对底层数据模式的任何修改都要添加，删除或修改定义类的代码。
    匿名类可以简化这个编程模式的一种方式。

    例：

    var curries = new[]

    {
        new { MainIngredient="Lamb", Style="Dhansak", Spiciness = 5},

        new { MainIngredient="Lamb", Style="Dhansak", Spiciness = 5},

        new { MainIngredient="chicken", Style="Dhansak", Spiciness = 5},

    };

   

    在IDE中查看var test = new {MainIngredient="Lamb", Style="Dhansak", Spiciness = 5}；中test的类型是'a, '符号在IntelliSense中表示匿名类型。

    匿名类型是只读的，不能修改。

    在上面实例化的过程中，编译器会对比所创建的实例，会创建一个类型的三个实例，而不是三个类型。但不会在程序中查找相对应的类型进行匹配。

42. 扩展方法
    扩展方法，可以扩展类型的功能，但无需修改类型本身。甚至可以扩展不能修改的类型，包括.net framework中定义的类型。

    语法：

        public static class ExtensionClass        //类需要时静态类
        {
            public static ReturnType ExtensionMethodName (this TypeToExtend instance)  //方法也要是静态的，this关键字必须有，TypeToExtend是要扩展的类。此处可以有多个参数。

            {
                .....

            }

        }

        调用方式： TypeToExtend myVar;      myVar.ExtensionMethodName(); 或 ExtensioClass.ExtensionMethodName(myVar);

       

    例：

        public static class ExtensionLibExtensions

        {
            public static string ToTitleCase(this string input string, bool forceLower)

            {
                inputString = inputString.Trim();

                if(...)......

            }

        }

       

        在程序中调用：   

        ...

        using ExtensionLib;  //类ExtensionLibExtensions所在的命名空间

        ...

        static void Main(string[] args)

        {
            ...

            string sourceString = Console.ReadLine();

            sourceString.ToTitleCase(true);  //true为方法声明中的第二个参数 bool foreceLower.

        }

43. λ表达式
    λ表达式用于简化C#编程的某些方面，尤其是与LINQ合并的方面。

    
    把λ表达式用于匿名方法：

        例：

             
            myTimer.Elapsed += (source, e) =» Console.WriteLine("Event handler called after {0} milliseconds.", (source as Timer).Interval );  //应用λ表达式。
                                                                                                                                                                                  //(source, e)参数应用了匿名类型，会根据上下文推到类型。
                                                                                                                                                                                  // =»把参数列表 和 表达式体分开。
                                                        
            可以代替内联的匿名方法：

            myTimer.Elapsed += delegate(object source, ElapsedEventArgs e) {Console.WriteLine("Event handler called after {0} milliseconds.", (source as Timer).Interval );};

            这两段代码会被编译为相同 或 相似 的 MSIL代码。
   

    λ表达式的参数：
        上面的(source,e)采用了匿名类型。实际上也可以定义类型如： （int paramA , int paramB）=» paramA+ paramB

        但不可以（int paramA, paramB)=»....., 只能要么全部指定类型，要么全部采用匿名类型。 不能混用。

        如果，只有一个参数可以省略(),如： param1 =» param1*param1

   

        还可以，定义 无参数 的λ表达式，使用空括号来表示：() =» Math.PI  
        

    λ表达式的语句体：

         多行表达式时如下:

        （param1, param2）=»

         {
            // 多行表达式

            return returnvalue; //如果有返回类型，可以使用return语句。

         }

         例：

            PerformOperations((int paramA, int paramB)=»param1+param2);

            可以改写为：

            performOperations(delegate(int paramA, int paramB) {return paramA+ paramB;});

            还可改写为：

            performOperations((int paramA, int paramB) =» { return paramA+paramB;});

          单一表达式时，使用λ表达式比较简单。多个语句是，建议使用非匿名方法，这便于代码重用。

   

    λ表达式用做委托 和 表达式树：

        λ表达式有两种解释：

            ·i 解释为 委托 （如上面所描述的一样）

                一般可以把拥有至多4个参数 的表达式 表示为如下 泛型类型：

                    ·Action«»表示 不带 参数， 返回 void

                    ·Action«»表示 至多4个参数， 返回 void
                    ·Func«»表示 至多5个参数，返回非 void类型 。 返回类型放在参数列表最后。如：Func«int, int, int» 意思是，有两个int参数，返回类型是int。

          

           ·ii 解释为 表达式树（与LINQ关系密切）

                表达式树 是 λ表达式 的抽象表示，但不能直接执行。可以使用表达式树已编程方式分析λ表达式，执行操作，以响应λ表达式。

                     例：

                        LINQ架构包含一个泛型类Expression«»,用于封装λ表达式。使用这个类的一种方式是提取C#编写的λ表达式，把它转换为等价的SQL脚本，以便在数据库中直接执行。

     λ表达式 和 集合：
        学习Func«»泛型委托后，理解System.Linq空间中为数组提供的扩展方法。例Aggregate()定义的其中一个版本：

        public static TSource Aggregate «TSource»(this IEnumerable«TSource» source, Func«TSource, TSource, TSource» func );

        调用：

        int[] myIntArray = {2,6,3};

        int result = myIntArray.Aggregate((param1, param2)=»param1+param2);  //这个表达式会使 λ表达式调用两次（有三个数，先计算2+6，再计算8+3）。最后result=11。