探寻C#3.5新特性

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

C# 3.5新特性：扩展方法

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

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

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

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

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

C# 3.5新特性：Lambda 表达式

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

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

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

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

或者

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

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

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

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

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

C# 3.5新特性：宽松委托

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

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

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

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

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

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

 
 
 
    
  
  
  
  1. public string Name ...{ get; set; }
    2.

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

C# 3.5新特性：分部方法

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

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

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

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

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

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

文章名称：探寻C#3.5新特性
文章来源：http://www.hantingmc.com/qtweb/news3/355303.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

商城网站知识

分类信息网

华泰海航　　 　外贸网站建设　　 　营销型网站建设　　 　成都标志设计　　 　APP定制　　 　温江做网站　　 　400电话办理　　 　成都集团网站建设　　 　成都搅拌罐车　　 　高防机房　　 　重庆联通机房托管　　 　网站ssl证书　　 　成都定制高级网站建设　　 　力比特工程　　 　成都西信机房托管　　 　成都口碑营销公司　　 　手机网站　　 　腾讯香港免备案空间　　 　成都商城网站开发　　 　广安网站建设