C#3.0中Lambda表达式详解

在C#2.0中，微软给我们带来了一些新的特性，例如泛型，匿名委托等。然而，这些新的特性多多少少会给人一种从别的语言中“抄”来的感觉（例如泛型类似C++的模板，一些特性类似Java中的一些东西）。但是在C#3.0中，微软给我带来的一些新特性可能是以前所有开发语言都没有的特性。这无疑大大的体现了C#3.0在开发语言中强大的优势。

在华池等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供做网站、成都网站制作 网站设计制作定制网站建设,公司网站建设,企业网站建设,成都品牌网站建设,成都营销网站建设,成都外贸网站建设,华池网站建设费用合理。

Lambda表达式

Lambda 表达式是一个匿名函数，它可以包含表达式和语句，并且可用于创建委托或表达式目录树类型。所有 Lambda 表达式都使用 Lambda 运算符 =>。关于Lambda更详细的讲解大家可以参看 MSDN。里面说的很清楚。

这里简单举个例子来说明Lambda的好处。Lambda在对匿名委托的处理上提供了更清楚的实施方式。例如在2.0中。我们可以写这样的代码：

 
 
 
    
  
  
  
  1. Code 
    2. 
  
  
  
  2. public class Example 
    3. 
  
  
  
  3. { 
    4. 
  
  
  
  4.    public static void Demo(System.Windows.Controls.TextBlock outputBlock) 
    5. 
  
  
  
  5.    { 
    6. 
  
  
  
  6.       Func convert = delegate(string s) 
    7. 
  
  
  
  7.          { return s.ToUpper(); }; 
    8. 
  
  
  
  8. 
  
  
  
  9.       string name = "Dakota"; 
    10. 
  
  
  
  10.       outputBlock.Text += convert(name) + "\n"; 
    11. 
  
  
  
  11.    } 
    12. 
  
  
  
  12. }
    13.

在 C# 中将 Func<(Of <(T, TResult>)>) 委托与匿名方法一起使用。

在3.0中，我们可以使用Lambda来更清楚的进行参数的传递：

 
 
 
    
  
  
  
  1. Code 
    2. 
  
  
  
  2. public class Example 
    3. 
  
  
  
  3. { 
    4. 
  
  
  
  4.    public static void Demo(System.Windows.Controls.TextBlock outputBlock) 
    5. 
  
  
  
  5.    { 
    6. 
  
  
  
  6.       Func convert = s => s.ToUpper(); 
    7. 
  
  
  
  7. 
  
  
  
  8.       string name = "Dakota"; 
    9. 
  
  
  
  9.       outputBlock.Text += convert(name) + "\n"; 
    10. 
  
  
  
  10.    } 
    11. 
  
  
  
  11. }
    12.

Lambda 表达式的基础类型是泛型 Func 委托之一。这样能以参数形式传递 lambda 表达式，而不用显式将其分配给委托。尤其是，因为 System.Linq 命名空间中许多类型方法具有 Func<(Of <(T, TResult>)>) 参数，因此可以给这些方法传递 lambda 表达式，而不用显式实例化 Func<(Of <(T, TResult>)>) 委托。这样可以使我们的代码更加简洁，逻辑上更易于理解。

对象的初始化

在C#中，对象的初始化也做了一些改进。一个新的功能就是提供了更方便的语法规则来声明变量的值。

假如我们声明一个Student对象：

 
 
 
    
  
  
  
  1. Code 
    2. 
  
  
  
  2. public class Student 
    3. 
  
  
  
  3. { 
    4. 
  
  
  
  4.     private string _stuName; 
    5. 
  
  
  
  5.     private string _stuAge; 
    6. 
  
  
  
  6.     private int _stuClass; 
    7. 
  
  
  
  7. 
  
  
  
  8.     public Student() { } 
    9. 
  
  
  
  9. 
  
  
  
  10.     public string StuName 
    11. 
  
  
  
  11.     { 
    12. 
  
  
  
  12.         get { return _stuName; } 
    13. 
  
  
  
  13.         set { _stuName = value; } 
    14. 
  
  
  
  14.     } 
    15. 
  
  
  
  15. 
  
  
  
  16.     public string StuAge 
    17. 
  
  
  
  17.     { 
    18. 
  
  
  
  18.         get { return _stuAge; } 
    19. 
  
  
  
  19.         set { _stuAge = value; } 
    20. 
  
  
  
  20.     } 
    21. 
  
  
  
  21. 
  
  
  
  22.     public int StuClass 
    23. 
  
  
  
  23.     { 
    24. 
  
  
  
  24.         get { return _stuClass; } 
    25. 
  
  
  
  25.         set { _stuClass = value; } 
    26. 
  
  
  
  26.     } 
    27. 
  
  
  
  27. 
  
  
  
  28. }
    29.

在C#2.0中，我们是这样声明变量并赋值的：

 
 
 
    
  
  
  
  1. Student stu = new Student(); 
    2. 
  
  
  
  2.         stu.StuName = "Brian"; 
    3. 
  
  
  
  3.         stu.StuAge = "21"; 
    4. 
  
  
  
  4.         stu.StuClass = "1班";
    5.

而在C#3.0中，我们可以这样初始化对象：

 
 
 
    
  
  
  
  1. Student stu2 = new Student  
    2. 
  
  
  
  2.         { 
    3. 
  
  
  
  3.             StuName = "Brian", 
    4. 
  
  
  
  4.             StuAge = "21", 
    5. 
  
  
  
  5.             StuClass = "1班"
    6. 
  
  
  
  6.         };
    7.

从代码中不难看出，C#3.0给我们提供了很方便得方式来进行对象的初始化工作。

查询

这个想必大家都应该有所耳闻，那就是鼎鼎大名的Linq。这是C#3.0中最独特好用的新特性之一。Linq改变了我们写数据应用程序的方式，先前，开发人员需要考虑并编写不用的代码来处理不同数据源中的数据（SQL Server ，XML ，Memory....）。LINQ很好的帮我们解决了这个烦人的问题。同时借助Lambda，我们可以更方便准确的查询我们想要的数据。

使用Linq简单的数据查询例子：

 
 
 
    
  
  
  
  1. Code 
    2. 
  
  
  
  2. private void BindGridView(string criteria) 
    3. 
  
  
  
  3.     { 
    4. 
  
  
  
  4.         string strConn = ConfigurationManager.ConnectionStrings["connstr"].ConnectionString; 
    5. 
  
  
  
  5.         NorthwindDb db = new NorthwindDb(strConn); 
    6. 
  
  
  
  6. 
  
  
  
  7.         IEnumerable results; 
    8. 
  
  
  
  8. 
  
  
  
  9.         if (criteria == string.Empty) 
    10. 
  
  
  
  10.         { 
    11. 
  
  
  
  11.             results=db.Employee.ToArray(); 
    12. 
  
  
  
  12.         } 
    13. 
  
  
  
  13.         else 
    14. 
  
  
  
  14.         { 
    15. 
  
  
  
  15.             results = (from c in db.Employee 
    16. 
  
  
  
  16.                           where c.FirstName.Contains(criteria) 
    17. 
  
  
  
  17.                           select c).ToArray(); 
    18. 
  
  
  
  18.              
    19. 
  
  
  
  19.         } 
    20. 
  
  
  
  20.         GridView1.DataSource = results; 
    21. 
  
  
  
  21.         GridView1.DataBind(); 
    22. 
  
  
  
  22.     }
    23.

变量声明

这里要说的是var。var是C#3.0中提供的用于声明变量的关键字，开发人员可以不考虑变量的类型就可以对变量进行声明（这一点用法非常类似Javascript）。但是两者还是有些差异。

相同点：用var来声明任何类型的局部变量。

不同点：它仅仅负责告诉编译器，该变量需要根据初始化表达式来推断变量的类型，而且只能是局部变量。

我们可以这样声明变量：

 
 
 
    
  
  
  
  1. var i= 10;  
    2. 
  
  
  
  2. var name = "edisundong";  
    3. 
  
  
  
  3. var numbers = new int[] { 1, 2, 3 }; 
    4.

var仅仅是个关键字，它并不是C#3.0中的一种新的类型，而是负责告诉编译器，该变量需要根据初始化表达式来推断变量的类型，上面的语句相当于

 
 
 
    
  
  
  
  1. int i= 10;  
    2. 
  
  
  
  2. string name = " edisundong ";  
    3. 
  
  
  
  3. int[] numbers = new int[] { 1, 2, 3 }; 
    4.

这里还需要注意几点：

1.在声明时必须同时赋值。

2.在使用var声明一个局部变量后，他仍然具备强类型。

 
 
 
    
  
  
  
  1. var integer = 10;  
    2. 
  
  
  
  2. integer = " edisundong "; 
    3.

编译时会报Cannot implicitly convert type string to int错误。

3. 初始化器表达式的编译期类型不能够是空(null)类型。

4. var的声明仅限于局部变量

扩展方法

以前如果我们想扩展一个类的功能必须直接源自于它并且从学其中的方法，在C#3.0中，介绍了一种很快捷的扩展功能的方法。

 
 
 
    
  
  
  
  1. Code 
    2. 
  
  
  
  2. public static class StudentExtensionMethods 
    3. 
  
  
  
  3.     { 
    4. 
  
  
  
  4.         public StudentExtensionMethods() 
    5. 
  
  
  
  5.         { 
    6. 
  
  
  
  6.             // 
    7. 
  
  
  
  7.             //TODO: 在此处添加构造函数逻辑 
    8. 
  
  
  
  8.             // 
    9. 
  
  
  
  9.         } 
    10. 
  
  
  
  10.         public static string GetStudentInformation(this Student stu) 
    11. 
  
  
  
  11.         { 
    12. 
  
  
  
  12.             return string.Format("Name: {0} {1} Age: {2}", stu.StuName, 
    13. 
  
  
  
  13.             stu.StuAge, stu.StuClass); 
    14. 
  
  
  
  14.         } 
    15. 
  
  
  
  15.     }
    16.

定义一个类，其中定义一个方法，注意：这个类和方法都是static的，并且方法的参数是类Student。这样，Student类就可以扩展GetStudentInformation方法：

 
 
 
    
  
  
  
  1. Code 
    2. 
  
  
  
  2. Student stu2 = new Student 
    3. 
  
  
  
  3.             { 
    4. 
  
  
  
  4.                 StuName = "Brian", 
    5. 
  
  
  
  5.                 StuAge = "12", 
    6. 
  
  
  
  6.                 StuClass = "1班"
    7. 
  
  
  
  7.             }; 
    8. 
  
  
  
  8.             Console.WriteLine(stu2.GetPersonInformation());
    9.

小结：初学了下C#3.0，感觉带来了不少惊喜，其中有很多新的特性是以前所未知的。C#3.0的新特性应该还不止这些，还需继续学习研究。

网站标题：C#3.0中Lambda表达式详解
标题网址：http://www.hantingmc.com/qtweb/news49/407599.html

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

广告

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

猜你还喜欢下面的内容

做网站知识

各行业网站

成都光华机房服务器托管　　 　成都网站设计　　 　成都网站优化　　 　鸿艺文化　　 　高端网站设计　　 　蜀锦在线　　 　四川胜锦安防　　 　四川正泰动物　　 　顺泽窗帘　　 　成都包装设计公司　　 　seo关键词优化　　 　成都app软件开发　　 　微信小程序开发　　 　电信机房托管　　 　中国（西部）云计算中心　　 　400电话申请　　 　温岭熙道网站　　 　成都网站设计　　 　葆金莱自动门　　 　公路打桩机