lambda + 闭包

#region lambda

/*
* 什么是 lambda
* 作用是什么
* 本质
* 使用环境
* 使用的前提条件是什么？
*
* 要理解委托，实际上 lambda（换个名字 ==== ld ）就是一个委托，啥时委托呢?就是将一个方法变成参数然后给其他方法调用
* 语法糖，一种偷懒的方式。
* lambda 微软发明出来的，用于 简化 “匿名方法” 的一种表达式了,也就是简化委托的过程
* https://www.cnblogs.com/kingmoon/archive/2011/05/03/2035696.html
/
/ lambad 运算符 => 左边列出了需要的参数，二右边定义了lambad 变量的方法的实现方法
*
*
* 有几种定义参数的方式， => 指定
* s => xx 前面的是参数，指定 参数 s 的值为 xx
*
* 如果使用委托 ，可以不指定，编译器会根据前后推算出参数的数据类型
* Func<double,double,double> a = (x,y) => xy;
* 也可以 指定参数的数据类型
* Func<double,double,double> a = (double x,double y) => xy
*
* 如果 lambda 只有一行代码，在方法块内就不需要花括号和return ,因为 编译器会添加一条隐式的 return 语句
* 可以这样
* Func<double,double> a = x => xx;
* 也可以这样
* Func<double,double> a = x =>{ retutn xx;}
*
* 上面时一行代码的情况下，如果是多行就必须加上 花括号和 return
*
* Task task = new Task(() =>
* {
* console.writeline(“Hello,Word!”);
* console.writeline(“Hello,Word!”);
* });
*
*/
class T
{
delegate int V(int x );
public static void Main()
{
}
}

/* 
 *  
 *  闭包 ----将函数内部和外部连接起来的桥梁 
 * https://baike.baidu.com/item/%E9%97%AD%E5%8C%85/10908873?fr=aladdin
 * 
 *  闭包 ---- 通过 lambda 表达式 访问表达式外部变量
 *  
 *  https://www.jianshu.com/p/c22db2a91989
 *  https://www.jb51.net/article/115528.htm
 *  lambda表达式的闭包是定义在外部上下文（环境）
 *  中特定的符号集，它们给这个表达式中的自由符号赋值。它将一个开放的、
 *  仍然包含一些未定义的符号lambda表达式变为一个关闭的lambda表达式，
 *  使这个lambda表达式不再具有任何自由符号。
 *  
 *  闭包是个什么东西呢？
 *  闭包就是把函数以及变量包起来，使得变量的生存周期延长。
 *  闭包跟面向对象是一棵树上的两条枝，实现的功能是等价的。
 *  
 * 资料看了一大堆，按照自己的理解就是
 * 
 * 你在方法 a 里面定义一个方法 b ，然后通过访问  b    访问  a  里面的 变量  
 * 这个时候的 b 就是---闭包，
 * 无论 b 在哪里被调用，都能访问到 a 里面的变量。 ---闭包的作用
 * 
 * A: 闭包的作用场景是啥呢？
 * B: 闭包可以读取其他函数内部变量。
 * C: 可以简单理解为定义在一个方法里面的方法， 内部方法拥有外部方法的内部变量的引用
 * D: 可以利用闭包 将某个方法里面的局部变量镶嵌到内存中，供某些方法在外部使用
 * E: 小D ,如果是这样的话，他就避开了垃圾回收机制，会一直储存在内存中，嗯，是个好主意,就是有点占内存。。。。
 * F: 
 *  
 * A: 为什么要用到闭包呢？
 * B: 因为编译器 规定不能直接获取方法内部变量的值，闭包就是用来填这个坑的。
 * 
 * A：那为什么不直接调用外层方法呢？
 * B: 如果因为，如果每次调用都得先实例这个方法会很麻烦，如果通过闭包实现的话，他的内部变量是一直储存在内存里的（类似于静态方法）
 * D: 而闭包可以很优雅地完成这个任务，偷懒是人类进步hahahahaaaaaaa
 * E: 更直白地说就是 延长了变量生命周期，
 * F: 那他为什么要延长生命周期呢？
 * G: 方便其他方法访问呐
 *  
 *  
 * A:什么是 作用域链 呢？
 * B: 在执行闭包程序的时候 当他检索自身没有检索到相应变量时，他会像上一层再次检索，知道找到为止
 */
//class T
//{
//    public static void Main()
//    {
//        var x = 1;
        
//        Action action = () =>
//        {
//            var y = 2;
//            var result = x + y;
//            Console.Out.WriteLine("result = {0}", result);
//        };
//        action();
//    }
//}

//*********************************************
//class T
//{
//     public static void Main()
//    {
//        A();
//    }
//    public static string A()
//    {
//        var x = 9;
//         string  gg()
//        {
//            Console.Out.WriteLine("在这个方法里面调用方法 A 的局部变量 x {0}",x);
//            return (string) gg();           
//        }
//        return (string)gg();

//    }
//}

//*************
//class T
//{
//    public static void Main()
//    {
//        int someVal = 7;
//        Func<int, int> f = x => x + someVal;
//        someVal = 3;
//        Console.WriteLine(f(2));
        /*
         * 对于 lambda 表达式  x=> x+someVal,编译器会创造一个匿名类，他有一个构造函数来传递外部变量的值。构造函数取决于从外部访问的变量数
         *  就像这样
         *  
         * public class 匿名类
         {
             private int someVal;
             public  匿名类 (int someVal)
             {
                 this.someVal=someVal;
             }
             public int AnonymousMethod(int x) => x + someVal;
         }
         *
         * 如果多线程使用闭包，可能会遇到并发冲突，
         * 
         * 
         */
//    }
//}          




#endregion