lambda是匿名函数，因为没有名字，也没有关键字引用自身，因此递归的编码就成了问题。

一、最简单有效的方案是：

Func
     
       f =null; //变量须先赋值才能使用f = n=> n==0?1:n*f(n-1);f(11); //==39916800
     

 

有人担心f会被恶意修改，因为就是一个委托变量，而且认为f是委托，而不是匿名函数自身，所以不算匿名函数递归。我觉得，虽然是委托，但是引用的就是匿名函数，函数指针调用的函数难道不是函数自身吗？

二、要避免变量被恶意修改，方案是：

Func
     
       f = null;f = n =>{Func
      
        f2 = null;f2 = x=> x==0?1:x*f2(x-1);return f2;}f(11);
      
     

 

皆大欢喜。

三、奇葩

Func
     
      
       ,Func
       
        > g = f => f = n => n==0?1:n*f(n-1);g(null)(11);
       
      
     

 

四、不动点技术

Func
     
       Fx
      
       (Func
       
        
         ,Func
         
          > g) {     return x=>g(Fx(g))(x); }Func
          
           
            ,Func
            
             > g = f => n => n==0?1:n*f(n-1);Fx(g)(11);
            
           
          
         
        
       
      
     

 

fx(g) 返回 x=>g(fx(g))(x)即是g ；f = fx(g)。 因为fx(g) = x=>g(fx(g))(x) 即等于g。

所以，f=g。即函数g(f) 等于g(g)调用自身。

这个不动点技术相当麻烦（理解起来费劲），因为c#语言的缺陷（泛型参数约束不能是委托等），不能够通用化Func<T,R>，也就是递归函数不能通用化，而需要编写n个不同Fx。

如：Func<T1,T2,R> Fx<T1,T2,R>(Func<Func<T1,T2,R>,Func<T1,T2,R>> g) 等。

不动点之所以能够成功，在于它生成了一个等价于g的委托。Fx(g)返回委托，而非递归自身，所以不会递归溢出（一开始我居然没留意到这点）。