从Delegate,匿名方法到Lamdba表达式

     首先看下面的数据集合：

  class Employee
    {
        public string id { set; get; }

        public string name { set; get; }
    }

List<Employee> lists = new List<Employee>() 
            {
                new Employee(){ id="1001", name="Ivan"},
                new Employee(){ id="1002", name="IT"},
                new Employee(){ id="1003", name="ISD"},
                new Employee(){ id="1004", name="SE"},
                new Employee(){ id="1005", name="CI"},
            };

     如果想要从中找到id=1003的记录，我们可以利用泛型集合List的Find方法。由于此方法参数为一个Predicate代理，所以就产生了下面的代码：

 //委托
            Predicate<Employee> pre = new Predicate<Employee>(isMary);
            Employee emp = lists.Find(pre);

            Console.WriteLine(emp.id + "---" + emp.name);

  private static bool isMary(Employee emp)
        {
            return emp.id == "1003";
        }

     想来这样也是可以达到目的的，但起始还可以简化代码：运用c# 2.0 的特性：匿名方法：

   //匿名方法
            Employee e = lists.Find(delegate(Employee info) { return info.id == "1003"; });

            Console.WriteLine(e.id + "----" + e.name);

     用匿名方法简化了代码，替代了委托的定义。
    而在C#3.X中，我们还可以利用Lamdba表达式进一步优化代码，而其更简洁：

 Employee e2 = lists.Find(info => info.id == "1003");
            Console.WriteLine(e2.id + "---" + e2.name);

注意：lamdba表达式： 参数列表（显示或者隐式）+“=》”+表达式

     上面的演变过程，我们通过反编译可以看到不管是匿名方法，还是lamdba表达式，编译器实际上为我们做了“生成相关代理”的动作，或者说其实际的执行还是通过代理实现的。而整个演变只不过是为开发者开发方便而进行的“前台”“改进”。   
     下面通过lamdba表达式在LINQ中的应用来说明这一点：

 static void Main()
        {
            string[] arrs = new string[] { "M001","K001","M002","L021","M001","M003"};

            //采用代理做法
            Func<string, bool> pre = new Func<string, bool>(getStr);
            var result = from item in arrs.Where(pre)
                         select item;

            //采用匿名方法
            var result2 = from item in arrs.Where(delegate(string s) { return s.StartsWith("M"); })
                         select item;


            //采用lamdba表达式
            var result3 = from item in arrs.Where(s=>s.StartsWith("M"))
                         select item;


            foreach (string s in result)
            {
                Console.WriteLine(s);
            }

        }

        private static bool getStr(string s)
        {
            return s.StartsWith("M");
        }

     IL:

==================代理方式======================
    L_0034: ldftn bool LINQDemo.LamdbaDemo::isMary(class LINQDemo.Employee)
    L_003a: newobj instance void [mscorlib]System.Predicate`1<class LINQDemo.Employee>::.ctor(object, native int)
    L_003f: stloc.1 
    L_0040: ldloc.0 
    L_0041: ldloc.1 
    L_0042: callvirt instance !0 [mscorlib]System.Collections.Generic.List`1<class LINQDemo.Employee>::Find(class [mscorlib]System.Predicate`1<!0>)
    L_0047: stloc.2 
    L_0048: ldloc.2 
    L_0049: callvirt instance string LINQDemo.Employee::get_id()
    L_004e: call void [mscorlib]System.Console::WriteLine(string)
    L_0053: nop 
    L_0054: ret 
    
======================匿名方法==========================
    
    L_0030: ldsfld class [mscorlib]System.Predicate`1<class LINQDemo.Employee> LINQDemo.LamdbaDemo::CS$<>9__CachedAnonymousMethodDelegate3
    L_0035: brtrue.s L_004a
    L_0037: ldnull 
    L_0038: ldftn bool LINQDemo.LamdbaDemo::<Main>b__2(class LINQDemo.Employee)
    L_003e: newobj instance void [mscorlib]System.Predicate`1<class LINQDemo.Employee>::.ctor(object, native int)
    L_0043: stsfld class [mscorlib]System.Predicate`1<class LINQDemo.Employee> LINQDemo.LamdbaDemo::CS$<>9__CachedAnonymousMethodDelegate3
    L_0048: br.s L_004a
    L_004a: ldsfld class [mscorlib]System.Predicate`1<class LINQDemo.Employee> LINQDemo.LamdbaDemo::CS$<>9__CachedAnonymousMethodDelegate3
    L_004f: callvirt instance !0 [mscorlib]System.Collections.Generic.List`1<class LINQDemo.Employee>::Find(class [mscorlib]System.Predicate`1<!0>)
    L_0054: stloc.1 
    L_0055: ldloc.1 
    L_0056: callvirt instance string LINQDemo.Employee::get_id()
    L_005b: call void [mscorlib]System.Console::WriteLine(string)
    L_0060: nop 
    L_0061: ret 
=====================lamdba表达式==========================

    L_0030: ldsfld class [mscorlib]System.Predicate`1<class LINQDemo.Employee> LINQDemo.LamdbaDemo::CS$<>9__CachedAnonymousMethodDelegate3
    L_0035: brtrue.s L_004a
    L_0037: ldnull 
    L_0038: ldftn bool LINQDemo.LamdbaDemo::<Main>b__2(class LINQDemo.Employee)
    L_003e: newobj instance void [mscorlib]System.Predicate`1<class LINQDemo.Employee>::.ctor(object, native int)
    L_0043: stsfld class [mscorlib]System.Predicate`1<class LINQDemo.Employee> LINQDemo.LamdbaDemo::CS$<>9__CachedAnonymousMethodDelegate3
    L_0048: br.s L_004a
    L_004a: ldsfld class [mscorlib]System.Predicate`1<class LINQDemo.Employee> LINQDemo.LamdbaDemo::CS$<>9__CachedAnonymousMethodDelegate3
    L_004f: callvirt instance !0 [mscorlib]System.Collections.Generic.List`1<class LINQDemo.Employee>::Find(class [mscorlib]System.Predicate`1<!0>)
    L_0054: stloc.1 
    L_0055: ldloc.1 
    L_0056: callvirt instance string LINQDemo.Employee::get_id()
    L_005b: call void [mscorlib]System.Console::WriteLine(string)
    L_0060: nop 
    L_0061: ret 

========================生成的匿名方法===========

.method private hidebysig static bool <Main>b__2(class LINQDemo.Employee info) cil managed
{
    .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor()
    .maxstack 2
    .locals init (
        [0] bool CS$1$0000)
    L_0000: ldarg.0 
    L_0001: callvirt instance string LINQDemo.Employee::get_id()
    L_0006: ldstr "1001"
    L_000b: call bool [mscorlib]System.String::op_Equality(string, string)
    L_0010: stloc.0 
    L_0011: br.s L_0013
    L_0013: ldloc.0 
    L_0014: ret 
}


==========

    
      lamdba表达式代表一个内嵌的方法，（指向一个匿名的方法），可以传入任何接受delgegate型别的东西，大量用于LINQ中应用到任何匿名方法可以应用的场合，编译器会把lamdba表达式翻译成使用代理的匿名方法。

ps:

(1)

Delegate:

1.C#代理实际上类似于C++中的函数指针,因为C#中不存在指针,所以用代理可以完成一些原来在C++中用函数指针完成的操作,例如传递一个类A的方法m给另一个类B的对象，使得类B的对象能够调用这个方法m。但与函数指针相比，delegate有许多函数指针不具备的优点。首先，函数指针只能指向静态函数，而delegate既可以引用静态函数，又可以引用非静态成员函数。在引用非静态成员函数时，delegate不但保存了对此函数入口指针的引用，而且还保存了调用此函数的类实例的引用。其次，与函数指针相比，delegate是面向对象、类型安全、可靠的受控（managed）对象。也就是说，runtime能够保证delegate指向一个有效的方法，你无须担心delegate会指向无效地址或者越界地址。 

2.实现一个delegate，通过以下3个步骤即可实现一个delegate：
1)． 声明一个delegate对象，它应当与你想要传递的方法具有相同的参数和返回值类型。 
    声明一个代理的例子：
    public delegate int MyDelegate(string message);

2)． 创建delegate对象，并将你想要传递的函数作为参数传入。 
     创建代理对象的方法：
    1). MyDelegate myDelegate = new MyDelegate(实例名.方法名);
    2). MyDelegate myDelegate = new MyDelegate(类名.方法名);
注：如果需要代理的方法是一个static静态方法的话，采用第2种方式，否则采用第1种方式。

3)． 在要实现异步调用的地方，通过上一步创建的对象来调用方法。 
    可以直接使用代理调用代理所指向的方法:
    myDelegate(向方法传递的参数);

(2)匿名方法：
1.一个临时方法，这个方法只会使用一次，或者使用的很少。

2.方法的方法体很短，以至于比方法声明都短，(我将其称之为“一句话方法”)。

3.结合Delegate简化方法的定义和操作。

 

范例：
/Files/Ivan-Yan/DelegateDemo.rar