三、查询集合

正文内容

• 引入
• 概述
• 匿名函数
•     Lambda 表达式
•     匿有名的模特式

• 参考资料

  引入

本文在 VS 二零零六 环境下，解说本身对 Lambda 表明式、匿名函数、委托和 LINQ
谈谈本身的了解。小编对那一个题材的盘算，始于以下阶段：

• 结业刚加入工作时，使用 VS 200五 C#，它还不曾 LINQ
  天性。这时的重点精力在后台代码，早先控制了委托、泛型等，以及设计情势，并尝试编写
  JavaScript 代码，只是不太注重；
• 然后，尤其是跳槽后，对 JavaScript、jQuery、Ajax
  、DOM、HTML、CSS爆发了感兴趣，发现它们看似 JSON
  的书写格局很有意思，那时已经使用 VS
  2010，也有那种方法，由此在骨子里项目中时常地动用这种办法书写；
• 期间，知道了
  LINQ，觉得不错，在十分大程度上，接近自然语言，简化了代码逻辑和代码量；
• 但难题是，那种书写情势除了跟以前（VS 200五 前）完全分裂外，无论是
  JavaScript，还是C#，那种方法，能够在不定义变量，不定义函数名、形参和重返值类型等情景下利用，的确令人疑惑；
• 为了更加好的掌握那种书写格局，我上学了 JSON 的论争，之后是 Lambda
  表明式、LINQ。

反复，当您紧缺某方面知识时，对一个标题标知晓不恐怕深刻。

 

正文内容

• 寄托和泛型委托
  • 信托发展：C# 中央委员托的前进
  • 泛型委托
• 委托
  • 声明（定义）委托
  • 实例化委托
  • 调用委托
  • 用 Lambda表达式创设和实例化委托
• .NET 提供的嘱托
  • Action 委托
  • Func 委托
  • Predicate 委托
• 参考资料
• 修改记录

读书目录：

一.找出List<Product>列表中符合特定条件的有所因素

概述

咱俩都了解，定义三个函数，要出名字，大概要有形参列表、重返值类型。即正是前日，也是这么。

而 Lambda 演算（Lambda
calculus），告诉程序员们，其实不然，定义函数能够没著名字，未有形参列表，未有再次回到值类型，什么都并未有，只有函数体，1些表达式或是语句（今后通晓这是遵照Lambda 的门类推理），那正是匿名函数。

单向——委托，委托相当于函数（方法）指针（事件是信托的特例），那么完全能够应用匿名函数简化委托。拉姆da
表明式的申辩基础是拉姆da 演算（Alonzo Church, 一九三零）。

LINQ 就是依照 拉姆da 表达式（匿名函数）、泛型和简化的寄托。

本文的关键是从大的地点上领悟 Lambda 表达式和其选取，而不是它的语法。

 

下载 Deom

• 1.LINQ简述

• 2.LINQ优雅前奏的音符

  • 二.一.隐式类型
    (由编辑器自动依照表明式估摸出指标的末梢类型)
  • 二.二.目的初叶化器
    (简化了对象的创制及初叶化的经过)

  • ②.三.Lambda表达式
    (对匿名格局的创新，参与了信托签名的花色测度并很好的与发挥式树的3结合)

  • 二.四.扩大方法
    (允许在不改动类型的中间代码的情状下为类型丰裕独立的一颦一笑)

  • 贰.五.匿名类型
    (由对象初步化器估摸得出的档次，该品种在编译后自行成立)

  • 2.陆.表明式目录树(用数据结构表示程序逻辑代码)

• 三.LINQ框架的要害设计模型

  • 三.壹.链式设计方式(以流水生产线般的链接格局设计系统逻辑)

  • 三.二.链式查询办法(稳步加工查询说明式中的每二个工作点)

• 肆.LINQ框架的主旨设计原理

  • 四.一.托管语言之上的言语(LINQ查询表明式)

  • 4.二.托管语言构造的功底(LINQ依附通用接口与查询操作符对应的方法对接)

  • 四.三.深远IEnumerable、IEnumerable<T>、Enumerable(LINQ
    to Object框架的进口)

  • 4.4.尖锐IQueryable、IQueryable<T>、Queryable(LINQ
    to Provider框架的进口)
  • 四.5.LINQ针对分歧数据源的询问接口

• 5.动态LINQ查询(动态创设Expression<T>说明式树)

• 6.DLQashqai动态语言运维时(基于CLRAV4之上的动态语言运营时)

C#一.一 查询步骤：循环，if判断，打字与印刷

匿名函数

匿名函数是三个“内联（inline）”语句或表明式，可在急需委托项指标别样地方使用。能够动用匿名函数来初叶化命名委托，或传递命名委托（而不是命名委托项目）作为艺术参数。

有二种匿名函数：

• Lambda 表达式
• 匿名格局

下载更加多 德姆o

1】.LINQ简述

LINQ简称语言集成查询，设计的目标是为了消除在.NET平台上开始展览统1的数据查询。

微软中期的设计目标是为了化解对象/关系映射的消除方案，通过简单的应用类似T-SQL的语法进行数据实体的查询和操作。可是好的事物最终都能良性的升华演化，变成了最近.NET平台上攻无不克的集合数据源查询接口。

大家可以使用LINQ查询内存中的指标(LINQ
to Object)、数据库(LINQ to SQL)、XML文档(LINQ to
XML)，还有更加多的自定义数据源。

动用LINQ查询自定义的数据源供给借助LINQ框架为我们提供的IQueryable、IQueryProvider多少个轻重级接口。前边的稿子将教师到，那里先驾驭一下。

在LINQ未出现从前，大家需求理解很多对准分歧数据源查询的接口技术，对于OBJECT集合大家必要展开双重而干燥的循环迭代。对于数据库大家必要动用过多T-SQL\PL-SQL之类的数据库查询语言。对于XML大家须求选拔XMLDOM编制程序接口或然XPATH之类的东西，必要我们理解的事物太多太多，即费劲又便于忘。

那么LINQ是什么形成对两样的数据源进行合并的造访呢？它的雅致不是一天两日就修来的，归根结蒂还得谢谢C#的设计师们，是她们让C#能那样完美的演变，最后培养LINQ的幽雅。

下边大家来通过观望C#言语各样版天性子，匿名情势和Lambda。的每壹次演变，到底在哪个地方培育了LINQ的优雅前奏。

product类

C# 中央委员托的向上

• C# 1.0 中，通过用其余地点定义的艺术显式初叶化委托来创立委托的实例。
• C# 二.0 引进了匿有名的模特式（anonymous
  method）的概念，用匿超方式起始化委托，在委托中进行未命名的内联语句块。
• C# 三.0 引进了 Lambda
  表明式，与匿名格局的概念类似，但更具表现力并且更简约。匿名格局和兰姆da
  表达式统称为“匿名函数”。
• 常常，针对 .NET Framework 三.伍 及更加高版本应利用 拉姆da 表明式。

下边包车型地铁演示演示了从 C# 1.0 到 C# 三.0 委托创设进度的进步：

View Code

class Test
{
    delegate void TestDelegate(string s);
    static void M(string s)
    {
        Console.WriteLine(s);
    }

    static void Main(string[] args)
    {
        // C# 1.0: 最初的委托语法，用一个方法名初始化委托.
        TestDelegate testdelA = new TestDelegate(M);

        // C# 2.0: 用内联代码初始化委托，这个内联代码成为“匿名方法”.
        // 这个方法把一个字符串作为输入参数.
        TestDelegate testDelB = delegate(string s) { Console.WriteLine(s); };

        // C# 3.0: 用 Lambda 表达式初始化委托. 
        // Lambda 表达式也把一个字符串(x)作为输入参数.
        // 编译器可以推断 x 的数据类型.
        TestDelegate testDelC = (x) => { Console.WriteLine(x); };

        // 调用委托.
        testdelA("Hello. My name is M and I write lines.");
        testDelB("That's nothing. I'm anonymous and ");
        testDelC("I'm a famous author.");

        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}

运营结果：

View Code

Hello. My name is M and I write lines.
That's nothing. I'm anonymous and
I'm a famous author.
Press any key to exit.

 

寄托和泛型委托

---

委托完毕了函数指针，那么些函数指针跟 C
的函数指针分化，它是项目安全的，确定保障被调用的主意签名是没错的。只要方法签名跟委托签名相配，给委托的实例能够是实例方法，或是静态方法。

何以要有其一东西？大家对把数量作为函数参数很熟知，但奇迹，有些方法的操作不是指向数据，而是指向另二个方法。比如，线程，用线程去履行1个办法，或是代码段；再比如，事件，事件是寄托的特例，等等。

2】.LINQ优雅前奏的音符

Lamda 表达式

“Lambda
表达式”拓展了人们对函数的认识，简化了函数定义。而委托又是一个外表函数（方法）的指针，因而，也就简化了寄托。

Lambda
表达式是二个匿名函数，包括表明式或讲话，可用于创立委托或表明式树类型。

表明式都应用 拉姆da 运算符
=>。运算符右边是输入参数（假设有），右侧包括表达式或语句块。

创设委托，如下所示：

View Code

delegate int del(int i);
static void Main(string[] args)
{
    del myDelegate = x => x * x;
    int j = myDelegate(5); // j = 25
}

创设表明式树，如下所示：

View Code

using System.Linq.Expressions;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Expression<del> myET = x => x * x; //
        }
    }
}

在依据方法的 LINQ 查询中，如 Where，Lambda
表达式作为正式查询运算符方法的参数。

委托发展：C# 中央委员托的开拓进取

• C# 壹.0
  中，通过用在别的地点定义的诀窍显式起初化委托来创制委托的实例。
• C# 二.0 引进了匿有名的模特式（anonymous
  method）的定义，用匿名格局开首化委托，在委托中实施未命名的内联语句块。
• C# 三.0 引进了 兰姆da
  说明式，与匿有名的模特式的概念类似，但更具表现力并且更简明。匿名情势和
  拉姆da 表明式统称为“匿名函数”，类似闭包（Closure）性格。
• 日常，针对 .NET Framework 三.5 及更加高版本应利用 Lambda 表达式。

上面包车型地铁言传身教演示了从 C# 1.0 到 C# 三.0 委托创建进程的前行：

示例1：

View Code

namespace MyDelegate
{
    class Program
    {
        delegate void TestDelegate(string s);

        static void M(string s)
        {
            System.Console.WriteLine(s);
        }

        static void Main(string[] args)
        {
            // C# 1.0: 最初的委托语法，用一个方法名初始化委托.
            TestDelegate testdelA = new TestDelegate(M);

            // C# 2.0: 用内联代码初始化委托，这个内联代码成为“匿名方法”.
            // 这个方法把一个字符串作为输入参数.
            TestDelegate testDelB = delegate(string s) { System.Console.WriteLine(s); };

            // C# 3.0: 用 Lambda 表达式初始化委托. 
            // Lambda 表达式也把一个字符串(x)作为输入参数.
            // 编译器可以推断 x 的数据类型.
            TestDelegate testDelC = (x) => { System.Console.WriteLine(x); };

            // 调用委托.
            testdelA("Hello. My name is M and I write lines.");
            testDelB("That's nothing. I'm anonymous and ");
            testDelC("I'm a famous author.");

            System.Console.WriteLine("Press any key to exit.");
            System.Console.ReadKey();
        }
    }
}

运维结果：

View Code

Hello. My name is M and I write lines.
That's nothing. I'm anonymous and
I'm a famous author.
Press any key to exit.

– 2.一.隐式类型(由编辑器自动根据表明式估算出指标的末梢类型)

style=”font-family: medium; font-size: 一五px;”>隐式类型其实是编辑器玩的语法糖而已，不过它在极大程度上方便了我们编码。熟识JS的恋人对隐式类型不会面生，不过JS中的隐式类型与那里的C#隐式类型是有不小分其他。固然在语法上是同1的都以透过var关键字展开定义，不过相互最终的周转效果是全然不一样。

style=”font-family: medium; font-size: 1五px;”>JS是基于动态类型系统规划原理设计的，而C#是基于静态类型系统规划的，两者在设计原理上就不雷同，到最终的运转时更不如。

style=”font-family: 华文中宋; font-size: 一伍px;”>那里顺便推荐1本C#位置可比深刻的图书《深远解析C#》，想深远学习C#的心上人可以看看。这书有两版，第三版是我们耳熟能详的姚琪琳四弟翻译的很不利。借此感谢姚哥为大家翻译这么好的一本书。那本书很详细的授课了C#的发展史，包含广大布署的历史渊源。来自大师的真迹，格外具有学习参考价值，经天纬地的好书。

style=”font-family: medium; font-size: 壹5px;”>大家透过3个简约的小示例来火速的终止本小节。

View Code

 1 List<Order> OrderList = new List<Order>() 
 2             { 
 3                 new Order(){ Count=1}, 
 4                 new Order(){ Count=2}, 
 5                 new Order(){ Count=3} 
 6             }; 
 7             foreach (Order order in OrderList) 
 8             { 
 9                 Console.WriteLine(order.Count); 
10             }

此处小编定义了二个List<Order>对象并且发轫化了多少个值，然后通过foreach迭代数据子项。其实那种写法很符合规律，也很不难明白。不过从C#三起进入了var关键字，编辑器对var关键字展开了电动分析类型的帮衬，请看下边代码。

View Code

 1 var OrderList = new List<Order>() 
 2             { 
 3                 new Order(){ Count=1}, 
 4                 new Order(){ Count=2}, 
 5                 new Order(){ Count=3} 
 6             }; 
 7             foreach (var order in OrderList) 
 8             { 
 9                 Console.WriteLine(order.Count); 
10             }

编辑器能够智能的剖析出我们定义是何许品种，换句话说在不可胜计时候大家确实要求编辑器帮大家在编写翻译时规定目的类型。那在LINQ中很普遍，在您编写LINQ查询表明式时，你人为的去判断指标要回到的体系是很不具体的，可是由编写翻译器来机关的依照语法规则进行分析就很理想化了。由于LINQ注重于扩大方法，进行链式查询，所以类型在编写制定时是心有余而力不足鲜明的。前边的篇章将详细的讲课到，那里先了然一下。

 1 using System.Collections;
 2 using System.ComponentModel;
 3 
 4 namespace Chapter01.CSharp1
 5 {
 6     [Description("Listing 1.01")]
 7     public class Product
 8     {
 9         string name;
10         public string Name
11         {
12             get { return name; }
13         }
14 
15         decimal price;
16         public decimal Price
17         {
18             get { return price; }
19         }
20 
21         public Product(string name, decimal price)
22         {
23             this.name = name;
24             this.price = price;
25         }
26 
27         public static ArrayList GetSampleProducts()
28         {
29             ArrayList list = new ArrayList();
30             list.Add(new Product("West Side Story", 9.99m));
31             list.Add(new Product("Assassins", 14.99m));
32             list.Add(new Product("Frogs", 13.99m));
33             list.Add(new Product("Sweeney Todd", 10.99m));
34             return list;
35         }
36 
37         public override string ToString()
38         {
39             return string.Format("{0}: {1}", name, price);
40         }
41     }
42 }

Lambda 表达式

运算符左边是“拉姆da 表明式”。Lambda
表明式在组织表明式树时广泛利用。Lambda
表明式重回表达式的结果，接纳以下为主格局：

(input parameters) => expression

正如所示：

(x, y) => x == y

有时，编写翻译器难于或不能想见输入类型。此时得以显式钦命项目：

(int x, string s) => s.Length > x

采纳空括号钦赐零个输入参数：

() => SomeMethod()

泛型委托

示例 1 也可改写成泛型格局。如下所示：

示例 2：

View Code

namespace MyGenericDelegate
{
    class Program
    {
        delegate void TestGenericDelegate<T>(T s);

        static void GenericM<T>(T s)
        {
            System.Console.WriteLine(s);
        }

        static void Main(string[] args)
        {
            // C# 1.0
            TestGenericDelegate<int> testGenericDelA = new TestGenericDelegate<int>(GenericM);

            // C# 2.0
            TestGenericDelegate<string> testGenericDelB = delegate(string s) { System.Console.WriteLine(s); };

            // C# 3.0
            TestGenericDelegate<double> testGenericDelC = (x) => { System.Console.WriteLine(x); };

            // 调用委托.
            testGenericDelA(123456);
            testGenericDelB("That's nothing. I'm anonymous and ");
            testGenericDelC(123.456);

            System.Console.WriteLine("Press any key to exit.");
            System.Console.ReadKey();
        }
    }
}

运作结果：

View Code

123456
That's nothing. I'm anonymous and
123.456
Press any key to exit.

 

– 2.2.目的初始化器(简化了对象的创始及初叶化的长河)

style=”font-family: medium; font-size: 壹伍px;”>其实对象初叶化器是七个简单易行的语法立异，目标只怕为了便于大家进行对象的布局。(所谓万事俱备只欠DongFeng，那一个东风就是LINQ的方案。所以必须得先万事俱备才行。)

style=”font-family: medium; font-size: 一5px;”>那么对象初阶化器到底有没有多大的用处？大家仍旧先来观摩一下它的语法到底什么。

View Code

1 var order = new Order() { Count = 10, OrderId = "123", OrderName = "采购单" };//属性初始化
2 
3 var OrderList = new List<Order>() 
4             { 
5                 new Order(){ Count=1, OrderId="1",OrderName="采购单"}, 
6                 new Order(){ Count=2, OrderId="2",OrderName="采购单"}, 
7                 new Order(){ Count=3, OrderId="3",OrderName="采购单"} 
8             };//集合初始化

在意：对象伊始化器只好用在性质、公共字段上。

品质初叶化用那种语法编写的功能和直接用(order.Count=十;order.OrderId=”123″;order.OrderName=”购销单”;)是相等的。

集聚起始化使用大括号的多行语法也很简单领悟。类不现实的子对象的数码赋值是同样的。

自身想对代码有追求的意中人都会很喜欢那种语法，确实绝对美丽艳。

View Code

Lambda 语句

拉姆da 语句与 拉姆da 表明式类似，只是语句括在大括号中：

(input parameters) => {statement;}

Lambda 语句的主体能够涵盖自由数量的言语。

View Code

delegate void TestDelegate(string s);
…
TestDelegate myDel = n => { string s = n + "" + "World"; Console.WriteLine(s); };
myDel("Hello");

像匿名方式同样，Lambda 语句不恐怕用于制造表达式树。

委托

---

以示例 1 为例：

• 声明（定义）委托

  delegate void TestDelegate(string s);

各个委托描述了措施签名和重回类型等①体细节。如 TestDelegate
定义方法有两个 string 类型的参数 s，并且再次回到 void 类型。

能够在另内地方定义委托，跟定义二个类类似。委托也能够有访问修饰符。

• 实例化委托

  TestDelegate testdelA = new TestDelegate(M);

扬言委托后，必须用有些方法实例化那些委托。用艺术 M 去实例化委托
testdelA。

扬言（定义）和实例化委托，有点类似三个类，类也亟需定义，并实例化。

信托在语法上，总是带有1个参数的构造函数，这几个参数便是寄托引用的秘籍。也正是说，函数指针必须指向四个方法。

• 调用委托

  testdelA(“Hello. My name is M and I write lines.”);

实例化委托后，通过信托对象的称谓（前边是传递给委托的参数）调用委托对象。

寄托也足以构成、移除，如下所示：

namespace MyDelegate

{

    delegate void D(int x);

 

    class C

    {

        public static void M1(int i)

        {

            Console.WriteLine("C.M1: " + i);

        }

        public static void M2(int i)

        {

            Console.WriteLine("C.M2: " + i);

        }

        public void M3(int i)

        {

            Console.WriteLine("C.M3: " + i);

        }

    }

}

用如下代码测试：

D cd1 = new D(C.M1);

cd1(-1);                // call M1

D cd2 = new D(C.M2);

cd2(-2);                // call M2

D cd3 = cd1 + cd2;

cd3(10);                // call M1 then M2

cd3 += cd1;

cd3(20);                // call M1, M2, then M1

C c = new C();

D cd4 = new D(c.M3);

cd3 += cd4;

cd3(30);                // call M1, M2, M1, then M3

cd3 -= cd1;             // remove last M1

cd3(40);                // call M1, M2, then M3

cd3 -= cd4;

cd3(50);                // call M1 then M2

cd3 -= cd2;

cd3(60);                // call M1

cd3 -= cd2;                // impossible removal is benign

cd3(60);                // call M1

cd3 -= cd1;                // invocation list is empty so cd3 is null

//        cd3(70);        // System.NullReferenceException thrown

cd3 -= cd1;                // impossible removal is benign

• 用 拉姆da 表达式创制和实例化委托。

  Func myFunc = x => x == 5;

  bool result = myFunc(4); // returns false of course

其中，Func<int, bool> 是.NET
提供的已打包好的信托，用于以参数格局传递的法子，必须重临值。这样，就毫无显式声明定义委托。该信托输入参数为
int，重临类型为 bool。

 

– 2.三.兰姆da表达式(对匿名格局的改良，加入了委托签名的花色推测并很好的与发挥式树的3结合)

style=”font-family: medium; font-size: 一5px;”>小编想未有对象对Lambda表明式面生的，如若您对Lambda表达式面生的也没涉及，这里照看不误。前边再去补习一下就行了。

style=”font-family: medium; font-size: 一伍px;”>在LINQ的询问表明式中，随地都以拉姆da培养的高雅。通过封装匿名方法来达成强类型的链式查询。

style=”font-family: medium; font-size: 一伍px;”>Lambda是函数式编制程序语言中的特性，将函数一点也不细略的表示起来。不仅在动用时方便，查找定义也很有利。在急需的时候很简短定义就足以接纳了，幸免了在使用委托前先定义一个主意的麻烦。Lambda表明式与匿名委托在语法上是有分其余，当然那贰者都以对匿名函数的卷入。可是她们的面世是匿名委托早于拉姆da。所以看上去依旧拉姆da显得雅致。

style=”font-family: medium; font-size: 一伍px;”>上边大家来看二个小示例，简单的打听一下Lambda的施用原理，最重点的是它优于匿名委托哪个地方？

View Code

 1 /// <summary> 
 2         /// 按照指定的逻辑过滤数据 
 3         /// </summary> 
 4         public static IEnumerable<T> Filter<T>(IEnumerable<T> ObjectList, Func<T, bool> FilterFunc) 
 5         { 
 6             List<T> ResultList = new List<T>(); 
 7             foreach (var item in ObjectList) 
 8             { 
 9                 if (FilterFunc(item)) 
10                     ResultList.Add(item); 
11             } 
12             return ResultList;  
13         }

大家定义3个用来过滤数据的通用方法，那是个泛型方法，在选取时索要内定项目实参。方法有多少个参数，第一个是要过滤的数码集合，第二个是要拓展过滤的逻辑规则封装。

我们看一下调用的代码：

View Code

1 int[] Number = new int[5] { 1, 2, 3, 4, 5 }; 
2 IEnumerable<int> result = Filter<int>(Number, (int item) => { return item > 3; });
3 
4 foreach (var item in result) 
5             { 
6                 Console.WriteLine(item); 
7             }

大家那边定义的逻辑规则是，只要超过3的小编就把提取出来还要重临。很肯定那里的(int
item) => { return item > 3;
}语法段正是拉姆da表明式，它很有益于的包裹了点子的逻辑。从那一点上看拉姆da鲜明要比匿名委托强大很多，最重大的是它还扶助泛型的项目预计本性。

那正是说什么样是泛型的类别预计？

实际泛型的类型预计说简练点就是类别实参不要求大家来得的内定，编辑器能够经过分析表达式中的潜在关系活动的得出类型实参的品种。

说的有点空洞，我们照旧看现实的代码相比较明晰。

View Code

1 int[] Number = new int[5] { 1, 2, 3, 4, 5 }; 
2 var result = Filter(Number, (int item) => { return item > 3; });

笔者将上面包车型地铁代码修改成了不必要出示钦点泛型类型实参调用，那里也是能够的。

我们在定义Filter<T>泛型方法时将Func<T,bool>泛型委托中的T定义为匿名函数的参数类型，所以在我们采用的时候供给钦定出类型实参(int
item)中的item来表示委托将要利用的花色参数形参。在编辑器看来大家在概念泛型方法Filter时所用的泛型占位符T也恰巧是Filter方法的形参数据类型Func<T,bool>中选择的调用参数类型，所以那里的语法分析规则能纯粹的推测出我们接纳的1致种泛型类型实参。(此间要铭记近日IDE编辑器只辅助方式调用的泛型类型臆度，也正是说其余方面包车型大巴泛型使用是不扶助隐式的体系猜测，照旧须求大家手动加上项目实参。)

此地顺便提一下关于推迟加载技术，延迟加载技术在集合类遍历万分有用，越发是在LINQ中。很多时候我们对聚集的拍卖不是实时的，也等于说小编获得集合的数据不是二回性的，要求在自身要求实际的某三个项的时候才让自家去处理有关获取的代码。小编有点的更动了须臾间Filter代码：

View Code

 1 /// <summary> 
 2         /// 按照指定的逻辑过滤数据。具有延迟加载的特性。 
 3         /// </summary> 
 4         public static IEnumerable<T> FilterByYield<T>(IEnumerable<T> ObjectList, Func<T, bool> FilterFunc) 
 5         { 
 6             foreach (var item in ObjectList) 
 7             { 
 8                 if (FilterFunc(item)) 
 9                     yield return item; 
10             } 
11         }

这边运用了yield关键字，使用它大家得以在艺术内部形成三个自行的状态机结构。不难点讲也正是说系统会帮我们自行的兑现叁个继承了IEnumerable<T>接口的靶子，在事先我们要求协调去完成迭代器接口成员，很费时费劲而且性能不好。用那种艺术定义的章程后，我们唯有在遍历具体的联谊时办法才会被调用，也终于二个相当的大的性质升高。

泛型类型预计的不足之处;

自然类型预计还留存供不应求的地点，那里可以顺便参见一下大家老赵四哥的1篇文章：“C#编译器对泛型方法调用作类型测度的竟然问题”；笔者在实际上中国人民解放军海军事工业程高校业作中也遇上过二个很高烧难题，那里顺便跟大家享用一下。依照规律说自家在泛型方法的形参里面定义三个泛型的嘱托，他们的形参类型都以同等的占位符，不过只要本人利用含有形参的方法作为委托的参数的话是力不从心进行项目估摸的，然后使用无参数的办法作为委托参数是一点1滴没不平时的。然后必须选用Lambda表达式才能做科学的项目猜度，假如直接将包涵参数的有些方法作为委托的参数实行传递是力不从心开始展览实地的档次猜想，那里自身表示很不领悟。贴出代码与我们商讨一下那些标题。

自家定义四个艺术，那七个艺术未有啥样含义，只是四个有参数，一个一向不参数。

无参数的艺术：

View Code

1 public static List<Order> GetOrderList() 
2 { 
3 return new List<Order>(); 
4 }

有参数方法：

View Code

1 public static List<Order> GetOrderListByModel(Order model) 
2 { 
3 return new List<Order>(); 
4 }

Order对象只是3个品类，那里没有何特别意义。

多个包罗Func委托的秘籍，用来演示泛型的种类猜想：

View Code

1 public static TResult GetModelList<TResult>(Func<TResult> GetFunc) 
2 { 
3 return default(TResult); 
4 } 
5 public static TResult GetModelList<TSource, TResult>(Func<TSource, TResult> GetFunc) 
6 { 
7 return default(TResult); 
8 }

这边的标题是，即使小编利用GetOrderList方法作为GetModelList<TResult>(Func<TResult>
GetFunc)泛型方法的参数是未曾别的难题的，编辑器能如实的推论出泛型的门类。但是若是小编动用GetOrderListByModel作为GetModelList<TSource,
TResult>(Func<TSource, TResult>
GetFunc)重载版本的泛型方法时就不能够真切的估摸出类型。其实那里的Func中的TResult已经是艺术的回到类型，TSource也是方式的参数类型，按道理是完全能够进行项目揣测的。不过小编尝试了很各类方式就是过不起。奇怪的是要是自个儿使用带有参数和重临类型的Lambda表明式作为GetModelList<TSource,
TResult>(Func<TSource, TResult>
GetFunc)方法的参数时就能科学的品种测度。

主意调用的图例：

在图的第一行代码中，就是运用才有参数的主意调用GetModelList方法，不可能展开如实的花色预计。

小结：依据这几个分析，就好像对于措施的泛型类型猜测只限于拉姆da表达式？假如不是干什么多了参数就不恐怕开始展览项目测度？大家先留着那几个疑问等待答案吧；

ArrayListQuery类

含有标准查询运算符的 Lambda

重重行业内部查询运算符都具有输入参数，其项目是泛型委托的 Func<Of T,
TResult> 类别的个中之壹。如Enumerable.Count 方法、Enumerable.Max方法、Enumerable.Min 方法等等。

Func<Of T, TResult> 中的 “Of T”
表示输入参数的数量和种类；”TResult” 表示委托的回来类型。Func
委托对于利用在1组数据中各种成分相当管用。

譬如说，假如有以下委托项目：

View Code

public delegate TResult Func<TArg0, TResult>(TArg0 arg0)

若用 Func<int,bool> myFunc 来实例化这几个委托，那么，int
是输入参数，bool 是重返值。始终在最终八个品类参数中钦点再次回到值。若用
Func<int, string, bool> 来实例化，那么两个 int 和
string是输入参数，并且再次来到类型为 bool。

如下所示，调用上边 Func 委托，将回来 true 或 false
以提醒输入参数是还是不是等于 5：

View Code

Func<int, bool> myFunc = x => x == 5;
bool result = myFunc(4);

当参数类型为 Expression<Func> 时，也能够提供 Lambda 表明式，例如在
System.Linq.Queryable 内定义的正规化查询运算符中。如若钦赐Expression<Func> 参数，Lambda 将编写翻译为表达式树。

如下所示，演示1个正经查询运算符 Count 方法，总计整数 (n) 除以 二 余数为
一 的整数：

View Code

int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
int oddNumbers = numbers.Count(n => n % 2 == 1);

编译器可以估算输入参数的品类，恐怕您也足以显式内定该类型。

正如所示，演示重返数组 九 左侧的有着因素，因为 9是连串中不满意条件的率先个数字：

View Code

var firstNumbersLessThan6 = numbers.TakeWhile(n => n < 6);

.NET 提供的嘱托

---

– 二.4.恢弘方法(允许在不改动类型的当中代码的事态下为类型丰裕独立的一坐一起)

扩展方法的原目的在于于不改动对象内部代码的景色下对指标实行添加行为。这种方便性大大提升了大家对先后的扩充性，虽那小小的的扩充性在代码上来看不人微言轻，可是假若采纳巧妙的话将发挥十分大的效劳。扩大方法对LINQ的帮助十一分首要，很多指标原本营造与.NET贰.0的框架上，LINQ是.NET3.0的技巧，怎么样在不影响原有的目的境况下对目的开始展览添加行为很有挑衅。 

那么大家利用扩张方法就能够无缝的放权到此前的对象内部。那样的要求在做框架设计时很常见，最为典型的是我们编辑了贰个.NET②.0本子的DLL文件作为客户端程序使用，那么我们有亟待在服务端中对.NET二.0本子中的DLL对象加以控制。比如守旧的WINFO奥迪Q五M框架，大家能够将OCRUISERM实体作为窗体的控件数据源，让O逍客M实体与窗体的控件之间形成自然的照耀，包蕴对赋值、设置值都很有益于。可是如此的实业经过体系化后抵达服务层，然后通过检查进入到BLL层接着进入到DAL层，那个时候OQX56M框架须要利用该实体作相应的数据库操作。那么我们怎样使用.NET3.0的特色为O途睿欧M添加其余的表现呢？就算未有增加方法那里就很不可理喻了。有了扩充方法我们得以将扩张方法营造与.NET三.0DLL中，在增进对.NET二.0DLL的友元引用，再对OSportageM实体举办扩充。

咱俩来看一个小例子，看看扩充方法假如利用；

View Code

 1 public class OrderCollection 
 2 { 
 3   public  List<Order> list = new List<Order>(); 
 4 } 
 5 public class Order 
 6 { 
 7     public int Count; 
 8     public string OrderName; 
 9     public string OrderId; 
10 }

那边唯有是为了演示，相比较简单。作者定义了多个Order类和二个OrderCollection类，近年来线总指挥部的来说OrderCollection未有此外的法子，上面我们由此充足三个恢宏方法来为OrderCollection类添加一写计算格局，比如汇总、求和之类的。

怎样定义扩张方法？

壮大方法必须是静态类中的静态方法，我们定义1个OrderCollection类的扩张方法Count。

View Code

1 public static class OrderExtend 
2 { 
3     public static int Count(this OrderCollection OrderCollectionObject) 
4     { 
5         return OrderCollectionObject.list.Count; 
6     } 
7 }

扩充方法的首先个参数必须是this
关键开首然后经跟要壮大的目的类型，然后是扩大对象在运作时的实例对象引用。如若未有实例对象的引用作者想扩充方法也不用察觉。所以那里大家运用Count方法来集中壹共有多少Order对象。通过OrderCollectionObject对象引用我们就可以获得实例化的OrderCollection对象。

View Code

1 OrderCollection orderCollection = new OrderCollection(); 
2 orderCollection.Count();

再有三个亟待大家只顾的是，若是大家定义的扩展方法在别的的命名空间里，大家在应用的时候势须求在当前的CS代码中利用扩充方法所在的命名空间，要不然编辑器是不会去摸索你近年来在行使的对象的增加方法的，切忌。那里还有一些是内需大家注意的，当大家在布署后期恐怕会被扩大方法应用的靶申时索要一笔不苟的设想对象成员访问权限，假如我们将随后也许会被扩大方法运用的对象设计成受爱戴的仍然个人的，那么恐怕会波及到不可能最大力度的操纵。

Lambda 中的类型推理

在编排 拉姆da 时，经常不必为输入参数钦命项目，因为编写翻译器能够根据 拉姆da
主体、基础委托项目以及 C# 语言规范中描述的其他因素臆度类型。

对于大多数专业查询运算符，第一个输入是源种类瓜月素的门类。由此，即使要查询
IEnumerable<Customer>，则输入变量将被猜测为 Customer
对象，因而你能够访问其艺术和属性：

View Code

customers.Where(c => c.City == "London");

拉姆da 的形似规则如下：

• 拉姆da 包涵的参数数量必须与信托项目涵盖的参数数量同样。
• 拉姆da 中的每种输入参数必须都能够隐式转换为其相应的委托参数。
• Lambda 的再次来到值（如若有）必须能够隐式转换为委托的归来类型。

注意，Lambda 表明式自己并未有项目，因为健康项目系统并没有“拉姆da
表明式”这一中间概念。不过，有时会不标准地论及 Lambda
表明式的“类型”。在那么些处境下，类型是指委托项目或 Lambda 表明式所更换为的
Expression 类型。

Action 委托

该信托以参数情势传递一个履行某操作的不贰秘诀，不重临值。Action
委托有如下多少个重载：

• 美高梅开户网址 ，Action 委托
• Action<T> 委托
• Action<T1, T2> 委托
• Action<T1, T2, T3> 委托
• Action<T1, T2, T3, T4> 委托

.NET framework 4.0 提供的重载更加多。可提供 1陆 个输入参数。

示范 三：以 Action<T> 带八个参数的信托为例。

View Code

using System;

namespace MyAction
{
    class Program
    {
        // 声明委托
        delegate void DisplayMessage(string message);

        static void Main(string[] args)
        {
            // 用 ShowWindowsMessage，采用命名方法实例化 DisplayMessage 委托
            DisplayMessage messageTargetA = new DisplayMessage(ShowWindowsMessage);
            DisplayMessage messageTargetB = ShowWindowsMessage;
            // 用 ShowWindowsMessage，采用命名方法实例化 Action 委托
            Action<string> messageTargetC = ShowWindowsMessage;
            // 用 ShowWindowsMessage，采用匿名方法实例化 Acton 委托
            Action<string> messageTargetD = delegate(string s) { ShowWindowsMessage(s); };
            // 用 ShowWindowsMessage，采用 Lambda 表达式实例化 Acton 委托
            Action<string> messageTargetE = s => ShowWindowsMessage(s);

            messageTargetA("Hello, World!");
            messageTargetB("Hello, World!");
            messageTargetC("Hello, World!");
            messageTargetD("Hello, World!");
            messageTargetE("Hello, World!");
            System.Console.WriteLine("Press any key to exit.");
            Console.ReadKey();
        }
        private static void ShowWindowsMessage(string message)
        {
            System.Console.WriteLine(message);
        }
    }
}

运行结果：

View Code

Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Press any key to exit.

该示例最简便易行的花样也可写成：

View Code

Action<string> messageTarget = s => System.Console.WriteLine(s);
messageTarget("Hello, World!");
System.Console.WriteLine("Press any key to exit.");
Console.ReadKey();

– 二.伍.匿名类型(由对象初始化器臆想得出的项目，该类型在编写翻译后自动创造)

匿名类型其实也是相比好精通的，顾名思义匿名类型是绝非类型定义的品类。那连串型是由编辑器自动生成的，仅限于当前上下文使用。废话少说了，大家依然看例子吗；

View Code

1 var Student1 = new { Name = "王清培", Age = 24, Sex = "男", Address = "江苏淮安" }; 
2 var Student2 = new { Name = "陈玉和", Age = 23, Sex = "女", Address = "江苏盐城" };

定义匿名类型跟壹般的概念类型大约，只不过在new之后是一对大括号，然后经跟着你需求使用到的品质名称和值。

匿名类型的作用域；

匿名类型在选拔上是有它天生缺陷的，由于缺乏显示的类型定义，所以无法在艺术之间传递匿名类型。要想获取匿名类型的各属性值只可以通过反射的秘籍动态的获得运维时的习性对象，然后通过质量对象去取得到属性的值。匿名类型在行使的时候才会被创制项目，所以它在运维时存在着完全的指标定义元数据，所以经过反射获取数据是完全能够知晓的。

下边大家运用方面定义的门类来赢得它的逐壹属性。

View Code

 1 PrintObjectProperty(Student1, Student2);
 2 
 3 public static void PrintObjectProperty(params object[] varobject) 
 4 { 
 5     foreach (object obj in varobject) 
 6     { 
 7         foreach (System.Reflection.PropertyInfo property in obj.GetType().GetProperties()) 
 8         { 
 9             Console.WriteLine(string.Format("PropertyName:{0},PropertyValue:{1}", 
10                 property.Name, property.GetValue(obj, null))); 
11         } 
12     } 
13 }

图例：

由此反射的艺术我们就能够顺遂的获取到匿名类型的性质成员，然后经过质量音讯在胜利的收获到属性的值。

 1 using System;
 2 using System.Collections;
 3 using System.ComponentModel;
 4 
 5 namespace Chapter01.CSharp1
 6 {
 7     [Description("Listing 1.10")]
 8     class ArrayListQuery
 9     {
10         static void Main()
11         {
12             ArrayList products = Product.GetSampleProducts();
13             foreach (Product product in products)
14             {
15                 if (product.Price > 10m)
16                 {
17                     Console.WriteLine(product);
18                 }
19             }
20         }
21     }
22 }

何以：在询问中行使 拉姆da 表明式

不会在询问语法中一贯用到 Lambda
表明式，但会在方式调用中用到，并且询问表明式（查询语法）能够分包方法调用（方爱尔兰语法）。事实上，某个查询操作只好用艺术语法表示。

如下所示，查询语法与方克罗地亚共和国（Republika Hrvatska）语法：

View Code

class QueryVMethodSyntax
{
    static void Main()
    {
        int[] numbers = { 5, 10, 8, 3, 6, 12};

        // 查询语法:
        IEnumerable<int> numQuery1 = 
            from num in numbers
            where num % 2 == 0
            orderby num
            select num;

        // 方法语法:
        IEnumerable<int> numQuery2 = numbers.Where(num => num % 2 == 0).OrderBy(n => n);

        foreach (int i in numQuery1)
        {
            Console.Write(i + "");
        }
        Console.WriteLine(System.Environment.NewLine);
        foreach (int i in numQuery2)
        {
            Console.Write(i + "");
        }

        // Keep the console open in debug mode.
        Console.WriteLine(System.Environment.NewLine);
        Console.WriteLine("Press any key to exit");
        Console.ReadKey();
    }
}

运作结果：

View Code

6 8 10 12
6 8 10 12

以身作则一：演示使用标准查询运算符 Enumerable.Where，基于方保加利亚（Bulgaria）语法（Lambda
表明式）查询。注意，示例中的 Where 方法具有三个信托项目为
Func<TSource, Boolean>
的输入参数，委托行使整数作为输入，并再次回到布尔值。能够将 Lambda
表达式转换为该信托。假如 Queryable.Where 方法（LINQ to SQL
查询），则参数类型为 Expression<Func<int,bool>>，但 拉姆da
表明式看起来将完全相同。

View Code

// Enumerable.Where
// The call to Count forces iteration of the source
int[] scores = { 90, 71, 82, 93, 75, 82 };
int highScoreCount = scores.Where(n => n > 80).Count();
Console.WriteLine("{0} scores are greater than 80", highScoreCount);

// Queryable.Where
// Get all strings whose length is less than 6.
List<string> fruits = new List<string> { "apple", "passionfruit", "banana", "mango", 
           "orange", "blueberry", "grape", "strawberry" };
IEnumerable<string> query = fruits.AsQueryable().Where(fruit => fruit.Length < 6);
foreach (string fruit in query)
    Console.WriteLine(fruit);

Console.ReadKey();

运转结果：

View Code

4 scores are greater than 80
apple
mango
grape

以身作则二：演示在查询语法中动用情势语法（拉姆da 表明式）。Lambda
是必备的，因为不能够使用查询语法来调用 Sum 标准查询运算符。

询问首先按 GradeLevel
枚举中定义的方式，根据学生的实绩等级分组。然后，对各样组，添加各类学生的总分。那供给八个Sum 运算。内部的 Sum 总结每名学生的总分，外部的 Sum
保留该组中有所学生的运作统一计算。

View Code

// This query retrieves the total scores for First Year students, Second Years, and so on.
// The outer Sum method uses a lambda in order to specify which numbers to add together.
var categories =
from student in students
group student by student.Year into studentGroup
select new { GradeLevel = studentGroup.Key, TotalScore = studentGroup.Sum(s => s.ExamScores.Sum()) };

// Execute the query.
foreach (var cat in categories)
{
      Console.WriteLine("Key = {0} Sum = {1}", cat.GradeLevel, cat.TotalScore);
}

运营结果：

View Code

Key = SecondYear Sum = 1014
Key = ThirdYear Sum = 964
Key = FirstYear Sum = 1058
Key = FourthYear Sum = 974

Func 委托

该信托以参数方式传递的不②秘诀，必须再次回到值。Func 委托有如下多少个重载：

• Func<TResult> 委托
• Func<T, TResult> 委托
• Func<T1, T2, TResult> 委托
• Func<T1, T2, T3, TResult> 委托
• Func(<T1, T2, T3, T4, TResult> 委托

.NET framework 四.0 提供的重载更多。可提供 1陆 个输入参数。

演示 四：以 Func(T, TResult) 待二个参数的嘱托为例。

View Code

using System;

namespace MyFunc
{
    delegate string ConvertMethod(string inString);

    class Program
    {
        static void Main(string[] args)
        {
            // 用 UppercaseString，以命名方法实例化委托
            ConvertMethod convertMethA = UppercaseString;
            // 用 UppercaseString，以命名方法实例化 Func 委托
            Func<string, string> convertMethB = UppercaseString;
            // 以匿名方法实例化 Func 委托
            Func<string, string> convertMethC = delegate(string s) { return s.ToUpper(); };
            Func<string, string> convertMethD = delegate(string s) { return UppercaseString(s); };
            // 以 Lambda 表达式实例化  Func 委托
            Func<string, string> convertMethE = s => s.ToUpper();

            System.Console.WriteLine(convertMethA("Dakota"));
            System.Console.WriteLine(convertMethB("Dakota"));
            System.Console.WriteLine(convertMethC("Dakota"));
            System.Console.WriteLine(convertMethD("Dakota"));
            System.Console.WriteLine(convertMethE("Dakota"));

            System.Console.WriteLine("Press any key to exit.");
            System.Console.ReadKey();
        }
        private static string UppercaseString(string inputString)
        {
            return inputString.ToUpper();
        }
    }
}

运作结果：

View Code

DAKOTA
DAKOTA
DAKOTA
DAKOTA
DAKOTA
Press any key to exit.

该示例最简易的花样也可写成：

View Code

Func<string, string> convertMeth = s => s.ToUpper();
System.Console.WriteLine(convertMeth("Dakota"));
System.Console.WriteLine("Press any key to exit.");
System.Console.ReadKey();

– 二.陆.表明式目录树(用数据结构表示逻辑代码)

表明式目录树是LINQ中的重中之重，优雅其实就反映在那边。我们从匿名委托到拉姆daLamb达表明式在到今天的目录树，大家看出了.NET平台上的言语更是强大。我们并未有理由不去接受它的美。那么表明式目录树到底是啥东西，它的留存是为着消除什么的题材又或许是为了什么须要而留存的？

我们地方已经讲解过关于兰姆da表示式的定义，它是匿名函数的优雅编写方式。在拉姆da表明式里面是关于程序逻辑的代码，那一个代码通过编写翻译器编写翻译后就形成程序的运维时路径，根本不能够作为数据结构在程序中展开操作。比如在兰姆da表明式里面小编编写了那般一段代码
：(Student
Stu)=>Stu.Name==”王清培”，那么那段代码通过编译器编写翻译后就变成了豪门耳熟能详的微软中路语言IL。那么在很多时候大家须要将它的周转特点表现为多少结果，我们供给人工的去分析它，并且转变为其余1种语言依旧调用格局。那么为何在程序里面供给如此的多此一举，无法用字符串的不二等秘书诀表明Lambda表达式等价的表明情势呢？那样的目标是为了保险强类型的操作，不会招致在编译时不可能检查出的不当。而尽管大家选取字符串的办法来表述逻辑的结构，那么大家只辛亏运作时才能领略它的正确性，那样的没有错是很脆弱的，不晓得在怎样的情形下会出现难点。所以假若有了强类型的运营时检查我们就足以放心的应用Lambda这样的表明式，然后在供给的时候将它解析成各式各类的逻辑等式。

在.NET叁.5框架的System.Linq.Expression命名空间中引进了以Expression抽象类为表示的一堆用来代表表达式树的子对象集。那群对象集目标正是为着在运作时尽量的象征逻辑表明式的数据含义，让大家得以很方便的收获和分析那中数据结构。为了让通常的拉姆da表达式能被解析成Expression对象集数据结构，必须得借助Expression<T>泛型类型，该类型派生自LambdaExpression，它意味着Lambda类型的表达式。通过将Delegate委托类型的指标作为Expression<T>中的类型形参，编辑器会自动的将Lambda表明式转换来Expression表明式目录树数据结构。大家看来例子；

View Code

1 Func<int> Func = () => 10; 
2 Expression<Func<int>> Expression = () => 10;

编辑器对上述两行代码各使用了分歧的处理格局，请看跟踪对象意况。

不使用Expression<T>作为委托项目标包裹的话，该类型将是常见的嘱托项目。

即使利用了Expression<T>作为委托项指标包裹的话，编写翻译器将把它解析成继承自System.Linq.Expression.拉姆daExpression类型的目标。一旦成为对象，那么万事就好办多了，我们得以经过很不难的不贰诀窍取获得Expression内部的数据结构。

表达式目录树的对象模型；

地点简单的介绍了须臾间表明式目录树的打算和着力的规律，那么表达式目录树的接续关系恐怕说它的指标模型是何许样子的？大家唯有理清了它的完好布局那样才能方便大家未来对它举行应用和增加。

上边我们来分析一下它的内部结构。

(Student
stu)=>stu.Name==”王清培”，小编定义了3个Lambda表明式，大家得以视它为七个完好无损的表明式。什么叫全部的表明式，正是说完全能够用一个表明式对象来代表它，那里正是我们的LambdaExpression对象。表明式目录树的本来面目是用对象来表述代码的逻辑结构，那么对于2个完整的Lambda表明式我们必须能够将它完全的拆开才能够实行辨析，那么能够将Lambda表明式拆分成两有的，然后再各自对上3次拆开的两局地继续拆分，那样递归的拆下去就任其自流的演进壹颗表明式目录树，其实也正是数据结构里面包车型大巴树形结构。那么在C#里面大家很不难的布局出叁个树形结构，而且那颗树充满着多态。

(Student
stu)=>stu.Name=”王清培”，是1个什么体统的树形结构吧？大家来看一下它的周转时树形结构，然后在拓展抽象的继承图看一下它是什么样协会出来的。

上海体育地方中的第三个对象是Expression<T>泛型对象，通过跟踪新闻方可知见，Expression<T>对象继承自拉姆daExpression对象，而拉姆daExpression对象又连续自Expression抽象类，而在抽象里重写了ToString方法，所以大家在观察的时候是ToString之后的字符串表示情势。

Lambda表明式对象主要有两有个别组成，从左向右依次是参数和逻辑主旨，也就对应着Parameters和Body七个理解属性。在Parameters是享有参数的自读列表，使用的是System.Collection.ObjectModel.ReadOnlyCollection<T>泛型对象来囤积。

这边或然你已经参数疑问，貌似表明式目录树的创设真正很圆满，各样细节都有钦定的靶子来表示。不错，在.NET三.5框架中引进了成千成万用来代表表明式树逻辑节点的指标。那个目的都以直接或直接的继续自Expression抽象类，该类表示抽象的表明式节点。大家都精晓表明式节点种种各种，须要具体化后才能一直动用。所以在基类Expression中唯有两性子格，一个是public
ExpressionType NodeType { get;
}，表示近年来表达式节点的门类，还有其余叁个public Type Type { get;
}，表示方今表明式的静态类型。何为静态类型，正是说当没有成为表明式目录树的时候是哪些项目，具体点讲也正是寄托项目。因为在信托项目被Expression<T>泛型包装后，编译器是把它自动的编写翻译成表明式树的数据结构类型，所以那边须要保留下当前节点的忠实类型以备现在选取。

总计：到了那边实在早就把LINQ的某些备选干活讲完了，从一各类的语法增强到.NET5.0的类库的丰盛，已经为前面包车型大巴LINQ的到来铺好了道路。下边包车型大巴多少个小结将是最非凡的时刻，请不要错过哦。

作者：王清培

出处：

本文版权归小编和网易共有，欢迎转发，但未经我同意必须保留此段评释，且在小说页面明显地方给出原版的书文连接，不然保留追究法律义务的职务。

View Code

怎么：在 LINQ 外部使用 拉姆da 表明式

Lambda 表达式并不只限于在 LINQ
查询中使用。能够使用在供给委托值的任哪个地点方（约等于在能够应用匿名情势的别的地点）。上边演示怎么样在
Windows 窗体育赛事件处理程序中选拔 拉姆da 表明式。注意，输入的品类（Object
和 MouseEventArgs）由编写翻译器推理，因而不用在 Lambda 输入参数中显式给定。

View Code

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        // Use a lambda expression to define an event handler.
       this.Click += (s, e) => { MessageBox.Show(((MouseEventArgs)e).Location.ToString());};
    }
}

Predicate 委托

该信托定义一组条件并分明内定对象是或不是顺应那个规范的艺术。此委托由 Array
和 List<T> 类的三种办法运用，用于在集合中搜索成分。

演示 伍：演示在数组中查找第二个 X*Y>100000 的点。

View Code

using System;
using System.Collections.Generic;

namespace MyPredicate
{
    class Program
    {
        static void Main(string[] args)
        {
            Point[] points = { 
                                 new Point(){X = 100,Y = 200}, new Point(){X = 150,Y = 250}, 
                                 new Point(){X = 250,Y = 375}, new Point(){X = 275,Y = 395}, 
                                 new Point(){X = 295,Y = 450}, new Point(){X = 290,Y = 451}
                             };

            Point first = Array.Find(points, ProductGT10);
            Console.WriteLine("Found: X = {0}, Y = {1}", first.X, first.Y);
            System.Console.WriteLine("Press any key to exit.");
            System.Console.ReadKey();
        }
        class Point
        {
            public int X { get; set; }
            public int Y { get; set; }
        }
        private static bool ProductGT10(Point p)
        {
            if (p.X * p.Y > 100000)
                return true;
            else
                return false;
        }
    }
}

也足以那一个写：

View Code

Point[] points = { 
                     new Point(){X = 100,Y = 200}, new Point(){X = 150,Y = 250}, 
                     new Point(){X = 250,Y = 375}, new Point(){X = 275,Y = 395}, 
                     new Point(){X = 295,Y = 450}, new Point(){X = 290,Y = 451}
                 };

Point first = Array.Find(points,
    (p) =>
    {
        if (p.X * p.Y > 100000)
            return true;
        else
            return false;
    });
Console.WriteLine("Found: X = {0}, Y = {1}", first.X, first.Y);
System.Console.WriteLine("Press any key to exit.");
System.Console.ReadKey();

表明：无需出示创制委托，或是内定泛型方法的参数类型，因为编写翻译器会依据上下文本人鲜明。

 

贰.测试和打字与印刷分开

 

参考资料

 

---

• MSDN
  注解、实例化和动用委托.aspx) 
• MSDN
  提供的寄托 
• 事件（C#
  编制程序指南）.aspx)
• 委托（C#
  编制程序指南）.aspx)
• C# 3.0 Cookbook, Third Edition: More than 250 solutions for C#
  3.0 programmers-Delegates, Events, and Lambda
  Expressions
• C# 3.0: Master the fundamentals of C# 3.0-Delegates and
  Events
• 程序设计_猫老鼠主人

 

C#2.0

匿名格局

虽说先有的匿名格局，后有个别 拉姆da 表达式，但依旧在 拉姆da
后证实匿名方式。

在 2.0 之前的 C#
版本中，申明委托的唯一形式是采用命有名的模特式（也正是用艺术名开头化委托）。C#
贰.0 引进了匿超级模特式，而在 C# 3.0 及更加高版本中，拉姆da
表明式取代了匿名情势，作为编纂内联代码的首要选取办法。

唯独，本节有关匿超情势的新闻相同适用于 拉姆da
表明式。有1种意况，匿名格局提供了 拉姆da
表达式中所未有的法力。匿名格局使你能够不难参数列表，那代表能够将匿名格局转换为涵盖各类签名的委托。那对于
Lambda 表明式来说是不恐怕的。

上边演示实例化委托的三种办法，都会在调用委托时显示一条新闻：

• 使委托与匿名格局关联。
• 使委托与命有名的模特式 (DoWork) 关联。

View Code

// Declare a delegate
delegate void Printer(string s);

class TestClass
{
    static void Main()
    {
        // Instatiate the delegate type using an anonymous method:
        Printer p = delegate(string j)
        {
            System.Console.WriteLine(j);
        };

        // Results from the anonymous delegate call:
        p("The delegate using the anonymous method is called.");

        // The delegate instantiation using a named method "DoWork":
        p = new Printer(TestClass.DoWork);

        // Results from the old style delegate call:
        p("The delegate using the named method is called.");
    }

    // The method associated with the named delegate:
    static void DoWork(string k)
    {
        System.Console.WriteLine(k);
    }
}

运营结果：

View Code

The delegate using the anonymous method is called.
The delegate using the named method is called.

由此使用匿超级模特式，不必成立单独的格局，缩小了实例化委托所需的编码系统开发。

例如，如若创制方法所需的种类开发是不须要的，则内定代码块（而不是寄托）恐怕那么些管用。运行新线程就是2个很好的以身作则。无需为委托创立更加多措施，线程类即可创设贰个线程并且带有该线程执行的代码。

View Code

void StartThread()
{
    System.Threading.Thread t1 = new System.Threading.Thread
      (delegate()
            {
                System.Console.Write("Hello, ");
                System.Console.WriteLine("World!");
            });
    t1.Start();
}

 

修改记录

---

• 2015年1月29日 【UPDATE】

 

下载 Deom

下载越来越多 德姆o

product类

参考资料

Wiki Lambda 表达式

MSDN 匿名函数

MSDN 委托Func<Of T, TResult>

MSDN 表明式树Expression<Func>

System.Linq.Enumerable 类

System.Linq.Queryable 类

Good Math, Bad Math 关于Lambda 阐述

 

Alonzo Church 一九三9散文下载

 1 using System.Collections.Generic;
 2 using System.ComponentModel;
 3 
 4 namespace Chapter01.CSharp2
 5 {
 6     [Description("Listing 1.02")]
 7     public class Product
 8     {
 9         string name;
10         public string Name
11         {
12             get { return name; }
13             private set { name = value; }
14         }
15 
16         decimal price;
17         public decimal Price
18         {
19             get { return price; }
20             private set { price = value; }
21         }
22 
23         public Product(string name, decimal price)
24         {
25             Name = name;
26             Price = price;
27         }
28 
29         public static List<Product> GetSampleProducts()
30         {
31             List<Product> list = new List<Product>();
32             list.Add(new Product("West Side Story", 9.99m));
33             list.Add(new Product("Assassins", 14.99m));
34             list.Add(new Product("Frogs", 13.99m));
35             list.Add(new Product("Sweeney Todd", 10.99m));
36             return list;
37         }
38 
39         public override string ToString()
40         {
41             return string.Format("{0}: {1}", name, price);
42         }
43     }
44 }

View Code

ListQueryWithDelegates类

 1 using System;
 2 using System.Collections.Generic;
 3 using System.ComponentModel;
 4 
 5 namespace Chapter01.CSharp2
 6 {
 7     [Description("Listing 1.11")]
 8     class ListQueryWithDelegates
 9     {
10         static void Main()
11         {
12             List<Product> products = Product.GetSampleProducts();
13             Predicate<Product> test = delegate(Product p)
14                 { return p.Price > 10m; };
15             List<Product> matches = products.FindAll(test);
16 
17             Action<Product> print = Console.WriteLine;
18             matches.ForEach(print);
19         }
20     }
21 }

View Code

变量test的开首化使用了匿名形式，而print变量的开头化使用了方法组转换，它简化了从现有措施成立委托的经过。不仅简单而且有力！

ListQueryWithDelegatesCompact类

 1 using System;
 2 using System.Collections.Generic;
 3 using System.ComponentModel;
 4 
 5 namespace Chapter01.CSharp2
 6 {
 7     [Description("Listing 1.12")]
 8     class ListQueryWithDelegatesCompact
 9     {
10         static void Main()
11         {
12             List<Product> products = Product.GetSampleProducts();
13             products.FindAll(delegate(Product p) { return p.Price > 10; })
14                     .ForEach(delegate(Product p) { Console.WriteLine(p); });
15         }
16     }
17 }

View Code

三.用lambda表明式来测试

C#3.0

product

 1 using System.Collections.Generic;
 2 using System.ComponentModel;
 3 
 4 namespace Chapter01.CSharp3
 5 {
 6     [Description("Listing 1.3")]
 7     class Product
 8     {
 9         public string Name { get; private set; }
10         public decimal Price { get; private set; }
11 
12         public Product(string name, decimal price)
13         {
14             Name = name;
15             Price = price;
16         }
17 
18         Product()
19         {
20         }
21 
22         public static List<Product> GetSampleProducts()
23         {
24             return new List<Product>
25             {
26                 new Product { Name="West Side Story", Price = 9.99m },
27                 new Product { Name="Assassins", Price=14.99m },
28                 new Product { Name="Frogs", Price=13.99m },
29                 new Product { Name="Sweeney Todd", Price=10.99m}
30             };
31         }
32 
33         public override string ToString()
34         {
35             return string.Format("{0}: {1}", Name, Price);
36         }
37     }
38 }

View Code

ListQueryWithLambdaExpression类

 1 using System;
 2 using System.Collections.Generic;
 3 using System.ComponentModel;
 4 using System.Linq;
 5 
 6 namespace Chapter01.CSharp3
 7 {
 8     [Description("Listing 1.13")]
 9     class ListQueryWithLambdaExpression
10     {
11         static void Main()
12         {
13             List<Product> products = Product.GetSampleProducts();
14             foreach (Product product in products.Where(p => p.Price > 10))
15             {
16                 Console.WriteLine(product);
17             }
18         }
19     }
20 }

View Code

总结：

→C#一,条件和操作紧凑耦合两者都以硬编码的

→C#二,条件和操作分开，匿名格局使委托变得不难（匿有名的模特式推进难点的可分离性）

→C#三Lambda表达式使原则变得更易于阅读（拉姆da表明式增强了可读性）。