现在几乎所有语言都有Lambda表达式了吧，这里就简单写一些。

Lambda表达式的简单使用

//Lambda表达式的格式如下
//(parameters) => expression-or-statement-block
class Program
{
    static int tempFunc(int x) { return x * x; }
    static void Main()
    {
        Func<int, int> id1 = tempFunc;
        
        //较为复杂的写法，是一个语句块
        Func<int, int> id2 =/*往后是Lambda表达式*/ (x) => { return x * x; };
        
        //更加抽象的写法,一个表达式，第一个x对应参数，x*x的结果对应返回值
        Func<int, int> id3 =/*往后是Lambda表达式*/ x => x * x;
    }
}

对于外部变量的捕获

class Program
{
    static void Main()
    {
        int temp = 4;
        Func<int> lambda = () => temp++;
        temp = 8;
        Console.WriteLine(lambda());
        Console.WriteLine(temp);
    }
}

如上例所见，我们可以得到以下结论：

①Lambda表达式可以使用函数内部的、表达式外部的变量。

Lambda表达式引用外部变量被称为捕获变量（这个好像是动名词），捕获变量的表达式称为闭包。

②函数运行时会传入外部变量当时的值，而不是外部变量被捕获时的值。

按照这个例子来看，运行时temp的值是8而不是4，尽管temp是在值为4时被捕获的。

③函数运行时可以修改外部变量的值。

比如运行lambda之后，temp的值就被改变了。

然后我们来看第二个例子：

    class Program
    {
        static Func<int> Natual()
        {
            int seed = 0;
            return () => seed++;
        }
        static void Main()
        {
            Func<int> natual = Natual();
            natual();	//seed = 0，函数返回后变成1
            natual();	//seed = 1，函数返回后变成2
        }
    }

④捕获变量的生命周期会延伸到和委托的生命周期一致

体现在，seed在Natual的生命周期中，原先应当随函数的结束而被销毁，但现在它的生命周期延长到了和natual委托相同的长度。

据说，被捕获的变量会被存储到一个隐藏的类中去，因此它的生命周期变得不同。

Lambda表达式和匿名方法

匿名方法比Lambda表达式缺少了几个特性：

匿名方法没有隐式类型的参数；

匿名方法必须是一个语句块，而不能是表达式；

匿名方法并没有在赋值给Expression时将其编译为表达式树的能力（看不懂啦）

public delegate int NumDele(int x);
class Program
{
    static void Main()
    {
        NumDele square = delegate (int x) { return x * x; };
        //相当于下面这句
        NumDele lambda1 = (x) => {return x* x; };
        //相当于下面这句
        NumDele lambda2 = x => x * x;
    }
}