CSharpThinking委托相关（二）

学而不思则罔，思而不学则殆。

　　本章主要内容是介绍委托的发展历程及不同阶段的优缺点。文章最后给出了一些概念的解释。

　　 

关于委托：

　　C#1：用特定的签名实现委托，委托相当于方法的“指针”或者叫方法的引用。

　　　　不足：1.如果想实现一个小委托也要创建一个完整的新方法。

　　　　        2.方法名过长。

#region C#1
Button btn = new Button（）;
btn.Click += new EventHandler(tb_Click);

....

void tb_Click(object sender, EventArgs e)
{
      // throw new NotImplementedException();
}
#endregion

　　C#2：提供了匿名方法，泛型委托类型Action<T>. 以及带返回值的Predicate<T>(T obj)

　　　  优点：简化委托delegate（first,second){ return first < second}; 如果不需要参数值，可使用匿名委托 delegate{...} 。

            Button tb = new Button();
            tb.Click += delegate(object sender, EventArgs e)
            {
                Console.WriteLine(string.Format("非匿名委托，命令源{0}.", sender));
            };
            tb.Click += delegate
            {
                Console.WriteLine("匿名委托，无需参数。");
            };

　　   注：匿名方法是C#2以被捕捉的变量的形式来实现，在别的地方称为闭包的一个特性。 ---C#InDepth

　　

　　C#3：提供Lambda，表达式树和Linq

 　　1.Lambda表达式：（显式参数列表）=>{...}  

　　　　1.1.Lambda表达式发展历程

历程	表达式	备注
1.匿名方法	delegate(string Text){return Text.Length;}	匿名方法
2.转换为Lambda表达式	(string Text) => {return Text.Length;}	转换
3.单个表达式	(string Text) => Text.Length;	去除不必要的大括号
4.让编译器推断隐式参数类型	(Text) => Text.Length;	编译器能猜测的出来
5.去除不必要的括号	Text => Text.Length;	最简形式，但有限制

　　　　1.2.Lambda表达式针对List的操作: 编译器执行自动转换及缓存Lambda表达式

    public class Item { public int Year { get; set; } }

    public class Lambda表达式
    {
        public Lambda表达式() 
        {
            List<Item> Items = new List<Item>(); 

            Items.FindAll(item => item.Year < 1960); // Lambda表达式

　　　　　　 Items.FindAll(new Predicate<Item> (SomeAutoGenerateName)); // 编译器转化后的Lambda表达式，编译器会自动缓存Lambda表达式
        }

        private static bool SomeAutoGenerateName(Item item)
        {
            return item.Year < 1960;
        }
    }

　 　　1.3. 延迟加载

                恰当的时间真正做转换，使数据能在适当的位置以一种“Just-In-Time”方式提供.

var col = Enumerable.Range(0,10).Reverse();// 实际并未执行任何操作，执行时间为O(1);

foreach(var element in col)
{
      Console.WriteLine(element); // 此时调用才会真正执行....Reverse(), 前期只是准备。即，延迟执行。   
}

　　

　　2.表达式树 ：代码作为数据，树形表达式集合

　　　2.1.表达式树的工作方式：我们在程序中创建了一些逻辑块，将其表示成普通对象，然后要求框架将所有的东西都编译成可执行的“真实”的代码。可能永远也不会这样用，但有助于理解Linq的工作方式。

        /// <summary>
        /// 简洁版表达式树
        /// </summary>
        void SimpleExpressionTree()
        {
            Expression<Func<String, String, bool>> exp = (x, y) => x.StartsWith(y);
            var compiled = exp.Compile();
            Console.WriteLine(compiled("A", "B"));
        }

        /// <summary>
        /// 简洁版表达式树用lambdaExpression转换的实例
        /// </summary>
        /// <remarks>
        /// 目的：了解表达式树底层实现方式，便于了解工作流程。
        /// </remarks>
        void ComplexExpressionTree()
        {
            // 1.构造方法调用各个部件
            MethodInfo method = typeof(string).GetMethod("StartWith", new[] { typeof(string) });
            var target = Expression.Parameter(typeof(string), "x");
            var methodArg = Expression.Parameter(typeof(string), "y");
            Expression[] methodArgs = new[] { methodArg };
            // 2.创建调用表达式
            Expression call = Expression.Call(target, method, methodArgs);
            var lambdaParameters = new[] { target, methodArg };
            var lambda = Expression.Lambda<Func<string, string, bool>>(call, lambdaParameters);
            // 3.将Call转换成Lambda表达式
            var compiled = lambda.Compile();
            Console.WriteLine(compiled("A", "B"));
        }

 　　 2.2.表达式树常用在Linq，但不总是这样。 Linq = 表达式树+Lambda+扩展方法

Bjarne Stroustrup ：“我不会创建这样的工具，它所能做的，都是我可以想象得到的。”

　　  2.3.表达式树是构建动态语言的核心。

 

 

 重要概念解释：

一. 闭包：一个函数除了能通过提供给它的参数与环境的互动外，还能同环境进行更大程度的互动。 

例子：

         public delegate void MethodInvoker();
        void EnClosingMethod()
        {
            int outerVariable = 5; // 外部变量，未捕获。匿名方法没有用它，所以未捕获。
            string capturedVariable = "captured"; // 被匿名方法捕获的外部变量。

            if (DateTime.Now.Hour == 23)
            {
                int normalLocalVariable = DateTime.Now.Minute; // 普通方法的局部变量，作用域内没有匿名方法。
                Console.WriteLine(normalLocalVariable);
            }

            MethodInvoker x = delegate()
            {
                string anonLocal = "Local to anonymous method"; // 匿名方法的局部变量，只有在匿名方法被调用时才存在于正在执行的栈帧（Frame）中。
                Console.WriteLine(capturedVariable + anonLocal); // 捕获外部变量
            };

            x();
        }

被捕捉的变量的生存期延长，局部变量并不总是“局部”。

        static MethodInvoker CreateDelegateInstance()
        {
            int counter = 5; // 不要认为counter的作用域仅仅在CreateDelegateInstance中。
            MethodInvoker x = delegate()
            {
                Console.WriteLine(counter);
                counter++;
            };
            x();
            return x;
        }

        void Test() 
        {
            MethodInvoker invoker = CreateDelegateInstance();// 整个CreateDelegateInstance在堆上而非栈上，故能保存counter值。
            invoker();
            invoker();

            /* Output:
             * 5
             * 6
             * 7
             * */
        }

 使用多个委托来捕获多个变量的实例：

        public static void MutiDelegate()
        {
            List<MethodInvoker> list = new List<MethodInvoker>();

            for (int index = 0; index < 5; index++)
            {
                int counter = index * 10;
                list.Add(delegate()
                {
                    Console.WriteLine(counter);// 若改成index ，则输出全部为5
                    counter++;
                });
            }
             
            foreach (var item in list)
            {
                item(); // 执行委托实例
            }

            list[0]();// Output: 1
            list[0]();// Output: 2
            list[1]();// Output: 11

            /*
             * counter在循环内部声明，所以会生成5个counter副本。
             * 而index仅仅声明了一次，所以有唯一一个副本。
             * */
        }

 捕获变量小结：

1.捕获的是变量，而不是创建委托实例时它的值。

2.捕获的变量的生存期被延长了，至少和捕捉它的委托一样长。

3.多个委托可以捕获同一个变量。

4.必要时创建额外的类型来保存捕获变量。

5.如果用或不用捕获变量同样简单及简洁，那就不用。

6.考虑垃圾回收问题，尽量不要延长捕获变量的生存期。

  

二. C#3 编译器推断Lambda表达式中的参数类型，相比C#2要复杂的多。