匿名函数不足之处
　　虽然增加Lambda表达式，已经极大简化了我们的工作量。但确实有些不足之处：
　　var result = name => name;
　　这些写编译时是报错的。因为c#本身强类型语言的，提供var语法糖只是为了省去声明确定类型的工作量。 编译器在编译时必须能够完全推断出各参数的类型才行。代码中的name参数类型，显然在编译时无法推断出来的。
　　var result = (string name) => name;
　　Func<string， string> result2 = (string name) => name;
　　Expression<Func<string， string>> result3 = (string name) => name;
　　上面直接声明name类型呢，很遗憾这样也是报错的。代码中已经给出答案了，编译器推断不出右边表达式是属于Func<string， string>类型还是Expression<Func<string， string>>类型。
　　dynamic result = name => name;
　　dynamic result1 = (Func<string，string>)(name => name);
　　用dynamic呢，同样编译器也分不出右边是个委托，我们显示转换下可以了。
　　Func<string， string> function = name => name;
　　DynamicFunction df = function;
　　这里定义个func委托，虽然参数和返回值类型都和DynamicFunction委托一样，但编译时还是会报错：不能隐式转换Func<string， string>到DynamicFunction，2个类型是不兼容的。
　　理解c#中的闭包
　　谈论到动态创建函数，都要牵扯到闭包。闭包这个概念资料很多了，理论部分这里不重复了。 来看看c#代码中闭包：
　　Func<Func<int>> A = () =>
　　{
　　var age = 18;
　　return () =>  //B函数
　　{
　　return age;
　　};
　　};
　　var result = A()();
　　上面是闭包，可理解为是： 跨作用域访问函数内变量，也有说带着数据的行为。
　　C#变量作用域一共有三种，即：类变量，实例变量，函数内变量。子作用域访问父作用域的变量(即函数内访问实例/类变量)在我们看来理所当然的，也符合我们一直的编程习惯。
　　例子中匿名函数B是可以访问上层函数A的变量age。对于编译器而言，A函数是B函数的父作用域，所以B函数访问父作用域的age变量是符合规范的。
　　int age = 16;
　　void Display()
　　{
　　Console.WriteLine(age);
　　int age = 18;
　　Console.WriteLine(age);
　　}
　　上面编译会报错未声明使用，编译器检查到函数内声明age后，作用域会覆盖父作用域的age，(像JSundefined了)。
　　Func<int> C = () =>
　　{
　　var age = 19;
　　return age;
　　};
　　上面声明个同级函数C，那么A函数是无法访C函数中的age变量的。 简单来说是不可跨作用域访问其他函数内的变量。 那编译器是怎么实现闭包机制的呢？

　　如上图，答案是升级作用域，把A函数升级为一个实例类作用域。 在编译代码期间，编译器检查到B函数使用A函数内变量时，会自动生成一个匿名类x，把原A函数内变量age提升为x类的字段(即实例变量)，A函数提升为匿名类x的实例函数。下面是编译器生成的代码(精简过)：
class Program1
{
static Func<Func<int>> CachedAnonymousMethodDelegate2;
static void Main(string[] args)
{
Func<Func<int>> func = new Func<Func<int>>(Program1.B);
int num = func()();
}
static Func<int> B()
{
DisplayClass cl = new DisplayClass();
cl.age = 18;
return new Func<int>(cl.A);
}
}
sealed class DisplayClass
{
public int age;
public int A()
{
return this.age;
}
}
　　我们再来看个复杂点的例子：
　　static Func<int， int> GetClosureFunction()
　　{
　　int val = 10;
　　Func<int， int> interAdd = x => x + val;
　　Console.WriteLine(interAdd(10));
　　val = 30;
　　Console.WriteLine(interAdd(10));
　　return interAdd;
　　}
　　Console.WriteLine(GetClosureFunction()(30));
　　输出结果是20、40、60。 当看到这个函数内变量val通过闭包被传递的时候，我们知道val不仅仅是个函数内变量了。之前我们分析过编译器怎么生成的代码，知道val此时是一个匿名类的实例变量，interAdd是匿名类的实例函数。所以无论val传递多少层，它的值始终保持着，直到离开这个(链式)作用域。
　　关于闭包，在js当中谈论的比较多，同理，可以对比理解下：
　　function A() {
　　var age = 18;
　　return function () {
　　return age;
　　}
　　}
　　A()();
　　闭包的优点
　　对变量的保护。想暴露一个变量值，但又怕声明类或实例变量会被其他函数污染，这时可以设计个闭包，只能通过函数调用来使用它。
　　逻辑连续性和变量保持。 A()是执行一部分逻辑，A()()仅接着A()逻辑继续走下去，在这个逻辑上下文期间，变量始终都被保持着，可以随意使用。