Lambda表达式的诞生过程

这是一篇很经典的文章，解决了工作中一些使用过但是又不太明白的知识点，今天终于弄明白了。花了一晚上重新整的，坚决要分享出来！！！

那得从很久很久以前说起了，记得那个时候...

懵懂的记得从前有个叫委托的东西是那么的高深难懂。

委托的使用

例一：

public delegate void AddDelegate();
        public class Program
        {
            public Program()
            {
                AddDelegate add = new AddDelegate(Add);
            }
            public void Add()
            {
                Console.Write("hello");
            }
        }

什么是委托？

个人理解：用来传递方法的类型。（用来传递数字的类型有int、float、double，用来传递方法的就有委托）

例二：

 public delegate void Callback();
         class Program
         {
             public Program()
             {
                 SendMail(SavaLogOK, SaveLogErr);
             }
             public void SendMail(Callback sentResult, Callback errorAction)
             {
                 //...发送邮件...
                 if (true)
                     sentResult();  //发送成功
                 else
                     errorAction();  //发送失败
             }

             public void SaveLogErr()
             { }
             public void SavaLogOK()
             { }
         }

又经过了很久很久...

匿名方法

很多时候委托接收的方法是一次性的或者方法体是非常简单的...

例三：

 public delegate int AddDelegate(int a, int b);
         public class Program
         {
             public Program()
             {
                 AddDelegate addTest = new AddDelegate(Add);
                 addTest(,);//执行方法
             }
             public int Add(int a, int b)
             {
                 return a + b;
             }
         }

我们可以写成：

 public delegate int AddDelegate(int a, int b);
         public class Program
         {
             public Program()
             {
                 AddDelegate addTest = new AddDelegate(delegate(int a, int b) { return a + b; });
             }

         }

有没有发现我们每次都要定义委托，很多时候签名可能是一样的。这样就没有必要定义重复的。

然后又过了很久很久...

Func和Action

可能老大也觉得我们每次定义委托有点傻，所以干脆在框架内一次定义好所有可能用到的委托。那千变万化的方法签名怎么可能定义得全？没关系，定义成泛型的不就可以了吗。

先说Func：

 public delegate int AddDelegate(int a, int b);//这种委托不用在定义
         public class Program
         {
             public Program()
             {
                // AddDelegate addTest = new AddDelegate(delegate(int a, int b) { return a + b; });
                 Func<int, int, int> addTest = new Func<int, int, int>(delegate(int a, int b) { return a + b; });
             }

         }

细心的朋友可能看到了，Func相对于AddDelegate多定义了一个int。多出了的那个是指的是返回类型。我们F12看对应的定义：

  // 摘要:
     //     封装一个具有两个参数并返回 TResult 参数指定的类型值的方法。
     //
     // 参数:
     //   arg1:
     //     此委托封装的方法的第一个参数。
     //
     //   arg2:
     //     此委托封装的方法的第二个参数。
     //
     // 类型参数:
     //   T1:
     //     此委托封装的方法的第一个参数类型。
     //
     //   T2:
     //     此委托封装的方法的第二个参数类型。
     //
     //   TResult:
     //     此委托封装的方法的返回值类型。
     //
     // 返回结果:
     //     此委托封装的方法的返回值。
     [TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089")]
     public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2);

关于上面Func的写法我们可以简写成：（语法糖而已，编译后还是注释的代码）

  // AddDelegate addTest = new AddDelegate(delegate(int a, int b) { return a + b; });
                // Func<int, int, int> addTest = new Func<int, int, int>(delegate(int a, int b) { return a + b; });
                 Func<int, int, int> addTest = delegate(int a, int b) { return a + b; };

再看Action：

 class Program
         {
             public Program()
             {
                 SendMail(SavaLogOK, SaveLogErr);
             }
             public void SendMail(Action sentResult, Action errorAction)
             {
                 //...发送邮件...
                 if (true)
                     sentResult();  //发送成功
                 else
                     errorAction();  //发送失败
             }

             public void SaveLogErr()
             { }
             public void SavaLogOK()
             { }
         }

提醒：以后如果我们写代码的时候如果写到到delegate...，你要马上想到是否可以用Func或者Action来代替呢？C#4中的Action和Func有16个参数，足够你用了。

我们等了又等，又过了好久好久...

Lambda的诞生

  public Program()
             {
                 Func<int, int, int> addTest = delegate(int a, int b) { return a + b; };
                 Func<int, int, int> addTest2 = (int a, int b) => { return a + b; };
             }

我XX，这TM就是亲兄弟啊。直接去掉delegate关键字，然后加一个=>就成了lambda表达式了。（=>读作goes to）

我们继续简化：

 public Program()
             {
                 Func<int, int, int> addTest = (int a, int b) => { return a + b; };
                 Func<int, int, int> addTest2 = (a, b) => { return a + b; };
             }

丢掉参数类型也是可以的，因为强大的VS可以根据泛型委托Func自己推断出来参数类型。

还可以简化吗？当然：

                 Func<int, int, int> addTest = (int a, int b) => { return a + b; };
                 Func<int, int, int> addTest2 = (a, b) => { return a + b; };
                 Func<int, int, int> addTest3 = (a, b) => a + b;

return关键字也不要了，大括号也不要了。（当然，方法体只有单条语句才能怎么做）

现在看起来已经非常接近我们平时用的Lambda表达式了。

如果传入参数只有一个的话，我们还可以继续简化：

Func<int, int> func = (a) => * a;

func = a => * a;

这就是我们平时见得最多的lambda长相了。

要长成这样也是有要求的：

1. 只能有一个传入参数
2. 方法体只能只一条语句。

关于第1点，lambda我们平时用得较多的是基于IEnumerable或IQueryable，所以只能有一个参数也就满足了。

关于第2点，我们使用扩展方法的链式编程来解决。

如：（用链式来解决第二点）

 public Program()
             {
                 Func<IEnumerable<string>, IEnumerable<string>> fun = t =>
                     t.Where(v => v.Length > ).Reverse().OrderBy(v => v.Length).ToList();
             }

从此，我们过上了幸福的生活...

借《深入理解C#》中的一图：

小知识：（异步Lambda）

 Func<Student, Task<bool>> func = async t =>
 {
     await Task.Delay();//等待100毫秒
     return false;
 };

结束：

本文简短的说了下lambda表达式在C#中的一步步演化。说的不一定对，轻拍！

FROM :http://www.cnblogs.com/zhaopei/p/5769782.html