学步园

隐式类型本地变量(Implicity
Typed Local Variables)是一种在变量声明时编译器自动推断其变量类型的一种语法形式。它使用 var 关键字声明变量。例如：

1. var
   a = 1; 
2. var
   b = "Hello,
   Linq!"; 
3. var
   c = 2.23;

编译器根据类型推断，自动设别其变量类型，等同于如下声明形式：

1. int
   a = 1; 
2. string
   b = "Hello,
   Linq"; 
3. decimal
   c = 2.23;

注意，通过 var 关键字声明的变量，不能与用 object 声明的变量等同。var 声明的变量根据类型推断，在编译时和运行时的类型均为变量自身的真正类型；而用 object 声明的变量在编译时类型为 System.Object，并伴随一个隐式类型转换的过程。

C# 3.5新特性：对象和集合初始值设定项

该语法为简化对象和集合类型(如数组)的初始化赋值操作而产生。例如如下代码声明并初始化一个一个 List< string>。

1. List<
   string>
   list = new
   List< string>(); 
   
2. list.Add("This"); 
   
3. list.Add("Is"); 
   
4. list.Add("A"); 
   
5. list.Add("Collection");
   

可以使用如下方法直接进行初始化：

1. var
   list = new
   List< string>()
   ...{ "This",
   "Is",
   "A",
   "Collection"
   };

在任何实现了 Add 方法的类型上都可以使用集合初始值设定项。下面的示例展示了如何创建一个这样的类型。

1. public
   class
   Persons ...{ 
2. private
   List< string>
   list = new
   List< string>(); 
   
4. public
   void
   Add(string
   name) ...{ 
5. list.Add(name); 
   
6. } 
   
8. static
   void
   Main() ...{ 
9. var
   p = new
   Persons() ...{ "1",
   "2",
   "3"
   }; 
10. }
    

对象初始值设定项则可以更加直接的初始化一个对象的实例，例如对于 Person 类，有公开的 Name, Age 和 Height 属性，在实例化 Person 的时候，可以用如下语法形式。

1. public
   class
   Person ...{ 
2. public
   string
   Name ...{ get;
   set;
   } 
3. public
   int
   Age ...{ get;
   set;
   } 
4. public
   decimal
   Height ...{ get;
   set;
   } 
5. } 
   
7. var
   p = new
   Person ...{ Name = "Orochi",
   Age = 24, Height = 175 }; 
8. var
   persons = new[]
   ...{ 
9. new
   Person ...{ Name = "Orochi",
   Age = 24, Height = 175 }, 
10. new
    Person ...{ Name = "Blinda",
    Age = 23, Height = 165 }, 
11. new
    Person ...{ Name = "Ninicat",
    Age = 22, Height = 170 } 
12. }; 
    

代码中 persons 的类型被推断为 Person[]。

C# 3.5新特性：匿名类型

匿名类型常常用在查询表达式的结果中，因为这种类型的返回值往往是一个包含一种特定类型的 IEnumerable< T>。例如，要从上面的例子中选出年龄大于 21 岁，身高大于 160 厘米的 Person 集合，可以采用如下形式。

1. var
   result = from person in
   persons where person.Age >= 21 && person.Height
   >= 160 
2. select
   new
   ...{ Name = person.Name, Age = person.Age,
   Height = person.Height / 100 }; 
4. new
   { Name = person.Name, Age = person.Age, Height
   = person.Height / 100 } 是一个匿名类型，编译器将对它做如下声明。 
6. public
   class
   _Anonymous_Name_Age_Height ...{ 
7. public
   string
   Name; 
8. public
   string
   Age; 
9. public
   decimal
   Height; 
10. }
    

C# 3.5新特性：扩展方法

扩展方法将一个在特定类型上实现的方法引入到该类型上，并可利用该类型直接调用。

例如，Count() 方法可以计算元素的个数，Count() 方法可以实现在 string、数组、集合、IEnumerable< T> 上，甚至是上文中定义的 Persons 类上。为了在 string 上实现 Count()，可以使用如下代码。

1. using
   System.Runtime.CompilerService; 
3. public
   class
   Extensions ...{ 
4. [Extension()] 
   
5. public
   int
   Count(this
   string
   source) ...{ 
6. int
   count = 0; 
7. foreach
   (var item in
   source) ...{ 
8. count++; 
   
9. } 
   
10. return
    count; 
11. } 
    
13. [Extension()]
     
14. public
    int
    Count< T>(this
    IEnumerable< T> source) ...{ 
15. int
    count = 0; 
16. foreach
    (var T in
    source) ...{ 
17. count++ 
    
18. } 
    
19. return
    count; 
20. } 
    
21. }
    

这样，就在 IEnumerable< T> 上和 string 上都实现了 Count() 方法。我们可以象使用 IEnumerable< T> 和 string 上的成员方法一样使用扩展方法，例如：

1. string
   s = "Hello,
   World!"; 
2. int
   c1 = s.Count(); 
4. List<
   int>
   list = new
   List< int>()
   ...{ 1, 2, 3, 4, 5, 6 }; 
5. int
   c2 = list.Count();

C# 3.5新特性：Lambda 表达式

Lambda 表达式是一种匿名函数结构，它可以方便的实现委托、查询综合和扩展方法的 delegate 类型参数的初始化定义。例如：

1. delegate
   void
   Func(int
   x); 
3. void
   Add(int
   x) ...{ x ++; } 
5. Func
   f = new
   Func(Add); 
6. f(1);
   

可以使用更加简洁的方式实例化 f。

1. Func
   f = (x) => ...{ x++; };

或者

1. Func
   f = (int
   x) => ...{ x++; };

虽然上面的代码在实际中没有什么意义，但它为我们展示了一个更直观的委托实现方式。Lambda 表达式的基本语法为：

([[< 类型>] < 变量名>[, [< 类型>] < 变量名>]]) => { < 语句快> };

Lambda 表达式可以没有参数列表，如：

() => ...{ Console.WriteLine(""); };

C# 3.5新特性：宽松委托

宽松委托使得 C# 在判断委托实例化赋值时，对于签名不同的函数可以接受。例如 EventArgs 和 MouseEventArgs 是具备继承关系的类，当它们出现在同一个接受 EventArgs 类型参数的委托定义中时，编译器对于这两种委托都能接受。例如：

1. delegate
   void
   A (object
   sender, MouseEventArgs e); 
2. delegate
   void
   B (int
   a, int
   b); 
4. EventHandler
   e1, e2; 
5. e1
   = new
   A(...); //
   OK
6. e2
   = new
   EventHandler(...); //
   OK
7. e1
   = e2; //
   OK
9. B
   b = (long
   a, int
   b) +> ...{ }; //
   OK

C# 3.5新特性：自动实现属性

在定义类的属性时，常常需要像下面的代码一样封装一个域。

1. private
   string
   name; 
3. public
   string
   Name