http://developer.51cto.com/art/200908/147142.htm

 

    本文介绍了c# 3.5新特性,例如对象和集合初始值设定项,匿名类型,扩展方法,Lambda 表达式等。

    隐式类型本地变量(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>();  
    3.  
    4.     public void Add(string name) ...{  
    5.         list.Add(name);  
    6.     }  
    7.  
    8.     static void Main() ...{  
    9.         var p = new Persons() ...{ "1""2""3" };  

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

    1. public class Person ...{  
    2.     public string Name ...{ getset; }  
    3.     public int Age ...{ getset; }  
    4.     public decimal Height ...{ getset; }  
    5. }  
    6.  
    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 };  
    3.  
    4. new { Name = person.Name, Age = person.Age, Height = person.Height / 100 } 是一个匿名类型,编译器将对它做如下声明。  
    5.  
    6. public class _Anonymous_Name_Age_Height ...{  
    7.     public string Name;  
    8.     public string Age;  
    9.     public decimal Height;  

    C# 3.5新特性:扩展方法

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

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

    1. using System.Runtime.CompilerService;  
    2.  
    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.     }  
    12.  
    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.     }  

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

    1. string s = "Hello, World!";  
    2. int c1 = s.Count();  
    3.  
    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);  
    2.  
    3. void Add(int x) ...{ x ++; }  
    4.  
    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);  
    3.  
    4. EventHandler e1, e2;  
    5. e1 = new A(...);    // OK  
    6. e2 = new EventHandler(...);   // OK  
    7. e1 = e2;    // OK  
    8.  
    9. B b = (long a, int b) +> ...{ };   // OK 

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

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

    1. private string name;  
    2.  
    3. public string Name ...{ get ...{ return name; } set ...{ name = value; } } 

    C# 3.0 提供了一种简化的属性定义方法,可以实现上述代码的作用。

    1. public string Name ...{ getset; } 

    这就是自动实现属性。编译器自动实现类似域封装的代码。不过自动实现属性不能定义只读和只有 get 过程的属性;set 也不能具备访问性描述。

    C# 3.5新特性:分部方法

    分部方法允许开发人员在多个文件中定义一个类的方法。如:

    1. // 文件 1.cs  
    2. public partial class A ...{  
    3.     void B();  
    4. }  
    5.  
    6. // 文件 2.cs  
    7. public partial class A ...{  
    8.     void B ...{ Console.WriteLine("B invoked."); }  

    这种语法可以把函数的定义和声明分开编写。使用分部方法需要注意:

    1、分部方法的类实体必须为 partial。

    2、分部方法的返回值必须为 void。

    3、如果没有实现分部方法,但却定义了此方法的声明,在使用这个包含分部方法的类时,编译器自动将没有实现的方法签名移除。