委托的应用之Lambda表达式

　　首先我们通过下面的代码来看看委托逐步升级简化的过程。

namespace LambdaDemo
{
    class Program
    {
        delegate void ShowMethod(string name);
        static void Main(string[] args)
        {
            Test("star");
            Console.ReadLine();
        }

        public static void Test(string Name)
        {
            //.net framework 1.1 委托正常调用
            {
                ShowMethod method = new ShowMethod(DoSomething);
                method.Invoke(Name);
            }
            //.net framework 2.0
            {
                ShowMethod method = new ShowMethod(
                    delegate(string name)
                    {
                        Console.WriteLine("Hello ---- " + name);
                    }//匿名方法
                    );
                method.Invoke(Name);
            }
            //.net framework 3.0 (linq)
            {
                ShowMethod method = new ShowMethod(
                   (string name) => //lambda 匿名方法，其实也就是个方法 参数列表=>方法体
                   {
                       Console.WriteLine("Hello ---- " + name);
                   }
                    );
                method.Invoke(Name);
            }

            {
                ShowMethod method = new ShowMethod(
                   (name) => //参数类型可以去掉，因为委托的约束。
                   {
                       Console.WriteLine("Hello ---- " + name);
                   }
                    );
                method.Invoke(Name);
            }
            //如果方法体只有一行，则大括号和分号可以去掉
            {
                ShowMethod method = new ShowMethod(
                   (name) =>  Console.WriteLine("Hello ---- " + name)
                   );
                method.Invoke(Name);
            }
            //实例化委托可以简写 最终简化版
            {
                ShowMethod method = (name) => Console.WriteLine("Hello ---- " + name);
                method.Invoke(Name);
            }
        }

        private static void DoSomething(string name)
        {
            Console.WriteLine("Hello ---- " + name);
        }
    }
}

 　下面我介绍两个.net 自带的委托 Action ,Func

　

            Console.WriteLine("-----------Action-------");
            //Action 无返回值 接受0 到16个泛型参数的委托
            {
                Action act1 = () => Console.WriteLine("Hello ---- ");
                act1.Invoke();
                Action<string> act2 = (t) => Console.WriteLine("Hello ---- " + t);
                act2.Invoke("star");
                //如果只有一个参数可以去掉小括号
                Action<string> act3 = t => Console.WriteLine("Hello ---- " + t);
                act2.Invoke("star");
                Action<string, int, DateTime> act4 = (p1, p2, p3) => Console.WriteLine("Hello ---- ");
            }
            Console.WriteLine("-----------Action-------");
            //Func 有返回值 接受0 到16个泛型参数的委托
            {
                Func<int> func = () =>
                    {
                        int d = DateTime.Now.Day;
                        return d;
                    };
                int r = func.Invoke();
                Func<int> func1 = () => DateTime.Now.Day; //方法体只有一行可以去掉大括号，return
                Func<int, string> func2 = (p1) => p1.ToString();
                Func<int, DateTime, string> func3 = (p1, p2) => p2.ToString();
            }

 Lambda 表达式

{
                List<int> arr = new List<int>();
                arr.Add(1);
                arr.Add(2);
                arr.Add(3);
                arr.Add(4);
                arr.Add(5);
                arr.Add(6);


                //命名方法
                List<int> arr1 = arr.Where(GetNumList).ToList();
                //匿名方法
                List<int> arr2 = arr.Where(new Func<int, bool>(delegate(int t)
                {
                    return t % 2 == 0;
                })).ToList();
                //匿名方法
                List<int> arr3 = arr.Where(delegate(int t)
                {
                    return t % 2 == 0;
                }).ToList();
                //Lamada 表达式 
                List<int> arr4 = arr.Where(t => t % 2 == 0).ToList();
            }


 private static bool GetNumList(int n)
        {
            return n % 2 == 0;
        }

总结

lambda 表达式 就是一个匿名方法，就是简单化了委托的声明和调用，从而精简了代码量。Lambda运算符=>，该运算符读作"goes to"。