我也表达式一回

看了老赵和老袋的表达式的文章(使用Lambda表达式编写递归函数)，今天我也照着表达式了一回。把自己的理解写了下来。以飨各位父老乡亲。
什么都不说了，直接看代码吧。我的牢骚都发在代码里了，这里就不再发牢骚了。

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Security.Principal;
using System.Web;
using System.Web.Mvc;
using System.Web.Security;
using System.Web.UI;
//using System.Linq;
//using System.Linq.Expressions;
//表达式在这个命名空间。不过这里用不到~老赵的那个快速计算表达式树需要这个。。。
//说起这个我就命苦了：我下不了他的代码~~可怜我看他的文章，把他的代码片段七拼八凑居然让我拼出来了。虽然还是是缺不全的，但可以编译通过。。。
//
//using System.Reflection;

namespace MVCControllers.GoodGoodStudy
{
    [HandleError]
    public class MVCStudyController : MyBaseController// View支持多级目录，根据Controller的当前的命名空间目录生成View路径
    {
        public ActionResult Index()
        {
            return GoodGoodStudyAction(0, "");
        }
        public ActionResult GoodGoodStudyAction(int id, string name)
        {
            ViewData["Message"] = "Welcome to ASP.NET MVC!<br />id=" + id.ToString() + "<br />name=" + name;
            //var fac = fac => x => x == 0 ? 1 : x * fac(x - 1);
            lambdaStudy();//
            Fibonacci();
            //view路径:/GoodGoodStudy/MVCStudy/GoodGoodStudyAction.aspx
            return View("GoodGoodStudyAction.aspx");//带扩展名，这样更灵活
        }
        
        public void lambdaStudy()
        {
            // The Y combinator(一个代理的“实现”)使用这个代理实际上就是给下面的递归函数的各部分安一个名字？？。
            // 不是。是实现了把这个类型的方法传给自己的逻辑。后面用它来把“F”传给自己。
            SelfApplicable<Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>>> Y = y => f => x => f(y(y)(f))(x);
            //Y:SelfApplicable<Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>>>
            //y:Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>>
            //f:Func<Func<int, int>, Func<int, int>>
                //参数为：Func<int, int>
                //返回值：Func<int, int>
            //x:int参数

            /**///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            //好像理解不准确(2009-9-15)。。。。无法理解(2009-9-15)。。。。终于理解了(2009-9-16)。。。。。
            //这种做法实际上是在调用的时候生成表达式树。传统的递归呢？应该也可以看做是调用时生成表达式树吧？所以性能都不好~~
            //对于理解了lambda表达式的同学，这样写确实更“语义”些，但对于还没有理解lambda表达式的同学来说确实很头痛，我到现在还头痛。。。
            //以下的理解用“函数”代表一个有参数的表达式。如果都用表达式，可能更说不清。因为所有代码都是表达式。似乎没有不能称为表达式的代码。
            /**///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

            //Y的作用：把自己（SelfApplicable<Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>>>）转换成Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>>


            //解释上面的代码：y(y)返回一个Func<Func<Func<int, int>, Func<int, int>>类型的方法
            //y(y)(f)== (y(y))  (f)前面是方法后面是参数f:Func<Func<int, int>, Func<int, int>>(y(y)(f))返回一个Func<int, int>类型的方法
            //f(y(y)(f))返回的也是一个方法。示意为：f(ff);其中ff=y(y)(f)返回的是一个Func<int, int>类型的方法。f(ff)返回的也是一个Func<int, int>类型的方法。
            //f(y(y)(f))(x)把f(y(y)(f))是一个方法用FF表示:FF(x)

            // The fixed point generator(递归？不是)把函数对象传给自己？
            Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>> Fix = Y(Y);

            // The higher order function describing factorial(这里在递归)
            Func<Func<int, int>, Func<int, int>> F = fac => x => x == 0 ? 1 : x * fac(x - 1);//递归在这。哈哈
            //F = fac => x => x == 0 ? 1 : x * fac(x - 1); 
            //fac => x => x == 0 ? 1 : x * fac(x - 1); 这是一个整体，表示一个函数。Func<Func<int, int>, Func<int, int>>它的参数和返回值都是函数
            //fac:是参数Func<int, int>
            //x => x == 0 ? 1 : x * fac(x - 1):是F的返回值（也是一个Func<int, int>）

            // The factorial function itself
            Func<int, int> factorial = Fix(F);//阶乘。
            
            //看下面的肥婆拉车数列的计算，用泛型改进了这个方法

            ViewData["Message"] += "阶乘<br />";
            for (int i = 0; i < 12; i++)
            {
                ViewData["Message"] += factorial(i) + "<br />";

                //Console.WriteLine(factorial(i));
            }
            /**///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            //简单总结一下：lambda表达式xx=>yy表示一个“函数”是一个整体。lambda表达式=>前面是参数，后面是方法体。
            /**///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        }

        public void Fibonacci()
        {//肥婆拉车数列.

            //非泛型方式
            //SelfApplicable<Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>>> Y = y => f => x => f(y(y)(f))(x);
            //Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>> Fix = Y(Y);

            //Func<Func<int, int>, Func<int, int>> F = fac => x => x == 0 || x == 1 ? 1 : fac(x - 2) + fac(x - 1);
            //Func<int, int> Fibonacci = Fix(F);//斐波那契数列


            //泛型方式
            Func<Func<int, int>, Func<int, int>> F = fac => x => x == 0 || x == 1 ? 1 : fac(x - 2) + fac(x - 1);//递归在这。哈哈
            Func<int, int> fibonacci = CommonSelfApplicable<int, int>(F);//斐波那契数列//肥婆拉车

            ViewData["Message"] += "肥婆拉车数列<br />";
            for (int i = 0; i < 12; i++)
            {
                ViewData["Message"] += fibonacci(i) + "<br />";
            }
        }


        /**//// <summary>
        /// 注意！！！！！
        /// 参数：SelfApplicable<T> 
        /// 返回：T
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="self"></param>
        /// <returns></returns>
        public delegate T SelfApplicable<T>(SelfApplicable<T> self);//一个代理的“声明”

        /**//// <summary>
        /// 一个参数的函数递归
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="TResult"></typeparam>
        /// <param name="func">任意一个参数的函数(lambda表达式,递归声明)</param>
        /// <returns></returns>
        public Func<T, TResult> CommonSelfApplicable<T, TResult>(Func<Func<T, TResult>, Func<T, TResult>> func)
        {
            //本来想直接把Func<T, TResult>定义为T。。。后来发现Func是delegate。。。泛不了型？改成<T, TResult>后发现这样似乎更好，更易懂。
            //实现把函数传给自己。(递归并不在这里面，递归本身在参数：func里)
            SelfApplicable<Func<Func<Func<T, TResult>, Func<T, TResult>>, Func<T, TResult>>> Y = y => f => x => f(y(y)(f))(x);
            Func<Func<Func<T, TResult>, Func<T, TResult>>, Func<T, TResult>> Fix = Y(Y);

            Func<T, TResult> SelfApplicableFunc = Fix(func);
            return SelfApplicableFunc;
        }

        /**//// <summary>
        /// 两个参数的函数递归
        /// </summary>
        /// <typeparam name="T1"></typeparam>
        /// <typeparam name="T2"></typeparam>
        /// <typeparam name="TResult"></typeparam>
        /// <param name="func"></param>
        /// <returns></returns>
        public Func<T1, T2, TResult> CommonSelfApplicable<T1, T2, TResult>(Func<Func<T1, T2, TResult>, Func<T1, T2, TResult>> func)// where T : Func<T, TResult>
        {
            //还没想到什么两个参数的递归。
            SelfApplicable<Func<Func<Func<T1, T2, TResult>, Func<T1, T2, TResult>>, Func<T1, T2, TResult>>> Y = y => f => (p1, p2) => f(y(y)(f))(p1, p2);
            Func<Func<Func<T1, T2, TResult>, Func<T1, T2, TResult>>, Func<T1, T2, TResult>> Fix = Y(Y);

            Func<T1, T2, TResult> SelfApplicableFunc = Fix(func);
            return SelfApplicableFunc;
        }
    }
}

    public class MVCStudyController : MyBaseController// View支持多级目录，根据Controller的当前的命名空间目录生成View路径
    {
        public ActionResult Index()
        {
            return GoodGoodStudyAction(0, "");
        }
        public ActionResult GoodGoodStudyAction(int id, string name)
        {
            ViewData["Message"] = "Welcome to ASP.NET MVC!<br />id=" + id.ToString() + "<br />name=" + name;
            //var fac = fac => x => x == 0 ? 1 : x * fac(x - 1);
            lambdaStudy();
            FibonacciTest();
            //view路径:/GoodGoodStudy/MVCStudy/GoodGoodStudyAction.aspx
            return View("GoodGoodStudyAction.aspx");//带扩展名，这样更灵活
        }
        
        public User GetUserName(Func<User, bool> exp)
        {/**//// Expression

            return null;
        }

        public void lambdaStudy()
        {
            // The Y combinator(一个代理的“实现”)使用这个代理实际上就是给下面的递归函数的各部分安一个名字？？。
            // 不是。是实现了把这个类型的方法传给自己的逻辑。后面用它来把“F”传给自己。
            SelfApplicable<Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>>> Y = y => f => x => f(y(y)(f))(x);
            //Y:SelfApplicable<Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>>>
            //y:Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>>
            //f:Func<Func<int, int>, Func<int, int>>
                //参数为：Func<int, int>
                //返回值：Func<int, int>
            //x:int参数

            /**///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
            //好像理解不准确(2009-9-15)。。。。无法理解(2009-9-15)。。。。终于理解了(2009-9-16)。。。。。
            //这种做法实际上是在调用的时候生成表达式树。传统的递归呢？应该也可以看做是调用时生成表达式树吧？所以性能都不好~~
            //对于理解了lambda表达式的同学，这样写确实更“语义”些，但对于还没有理解lambda表达式的同学来说确实很头痛，我到现在还头痛。。。
            //以下的理解用“函数”代表一个有参数的表达式。如果都用表达式，可能更说不清。因为所有代码都是表达式。似乎没有不能称为表达式的代码。
            /**///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

            //Y的作用：把自己（SelfApplicable<Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>>>）转换成Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>>


            //解释上面的代码：y(y)返回一个Func<Func<Func<int, int>, Func<int, int>>类型的方法
            //y(y)(f)== (y(y))  (f)前面是方法后面是参数f:Func<Func<int, int>, Func<int, int>>(y(y)(f))返回一个Func<int, int>类型的方法
            //f(y(y)(f))返回的也是一个方法。示意为：f(ff);其中ff=y(y)(f)返回的是一个Func<int, int>类型的方法。f(ff)返回的也是一个Func<int, int>类型的方法。
            //f(y(y)(f))(x)把f(y(y)(f))是一个方法用FF表示:FF(x)

            // The fixed point generator(递归？不是)把函数对象传给自己？
            Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>> Fix = Y(Y);

            // The higher order function describing factorial(这里在递归)
            Func<Func<int, int>, Func<int, int>> F = fac => x => x == 0 ? 1 : x * fac(x - 1);//递归在这。哈哈
            //F = fac => x => x == 0 ? 1 : x * fac(x - 1); 
            //fac => x => x == 0 ? 1 : x * fac(x - 1); 这是一个整体，表示一个函数。Func<Func<int, int>, Func<int, int>>它的参数和返回值都是函数
            //fac:是参数Func<int, int>
            //x => x == 0 ? 1 : x * fac(x - 1):是F的返回值（也是一个Func<int, int>）

            // The factorial function itself
            Func<int, int> factorial = Fix(F);//阶乘。
            
            //看下面的肥婆拉车数列的计算，用泛型改进了这个方法

            ViewData["Message"] += "阶乘<br />";
            for (int i = 0; i < 12; i++)
            {
                ViewData["Message"] += factorial(i) + "<br />";

                //Console.WriteLine(factorial(i));
            }
        }

        public void Fibonacci()
        {//肥婆拉车数列.

            //非泛型方式
            //SelfApplicable<Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>>> Y = y => f => x => f(y(y)(f))(x);
            //Func<Func<Func<int, int>, Func<int, int>>, Func<int, int>> Fix = Y(Y);

            //Func<Func<int, int>, Func<int, int>> F = fac => x => x == 0 || x == 1 ? 1 : fac(x - 2) + fac(x - 1);
            //Func<int, int> Fibonacci = Fix(F);//斐波那契数列


            //泛型方式
            Func<Func<int, int>, Func<int, int>> F = fac => x => x == 0 || x == 1 ? 1 : fac(x - 2) + fac(x - 1);//递归在这。哈哈
            Func<int, int> fibonacci = CommonSelfApplicable<int, int>(F);//斐波那契数列//肥婆拉车

            ViewData["Message"] += "肥婆拉车数列<br />";
            for (int i = 0; i < 12; i++)
            {
                ViewData["Message"] += fibonacci(i) + "<br />";
            }
        }


        /**//// <summary>
        /// 注意！！！！！
        /// 参数：SelfApplicable<T> 
        /// 返回：T
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="self"></param>
        /// <returns></returns>
        public delegate T SelfApplicable<T>(SelfApplicable<T> self);//一个代理的“声明”

        /**//// <summary>
        /// 一个参数的函数递归
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="TResult"></typeparam>
        /// <param name="func">任意一个参数的函数(lambda表达式,递归声明)</param>
        /// <returns></returns>
        public Func<T, TResult> CommonSelfApplicable<T, TResult>(Func<Func<T, TResult>, Func<T, TResult>> func)
        {
            //本来想直接把Func<T, TResult>定义为T。。。后来发现Func是delegate。。。泛不了型，改成<T, TResult>后发现这样似乎更好，更易懂。
            //实现把函数传给自己。(递归并不在这里面，递归本身在参数：func里)
            SelfApplicable<Func<Func<Func<T, TResult>, Func<T, TResult>>, Func<T, TResult>>> Y = y => f => x => f(y(y)(f))(x);
            Func<Func<Func<T, TResult>, Func<T, TResult>>, Func<T, TResult>> Fix = Y(Y);

            Func<T, TResult> SelfApplicableFunc = Fix(func);
            return SelfApplicableFunc;
        }

        /**//// <summary>
        /// 两个参数的函数递归
        /// </summary>
        /// <typeparam name="T1"></typeparam>
        /// <typeparam name="T2"></typeparam>
        /// <typeparam name="TResult"></typeparam>
        /// <param name="func"></param>
        /// <returns></returns>
        public Func<T1, T2, TResult> CommonSelfApplicable<T1, T2, TResult>(Func<Func<T1, T2, TResult>, Func<T1, T2, TResult>> func)// where T : Func<T, TResult>
        {
            //还没想到什么两个参数的递归。
            SelfApplicable<Func<Func<Func<T1, T2, TResult>, Func<T1, T2, TResult>>, Func<T1, T2, TResult>>> Y = y => f => (p1, p2) => f(y(y)(f))(p1, p2);
            Func<Func<Func<T1, T2, TResult>, Func<T1, T2, TResult>>, Func<T1, T2, TResult>> Fix = Y(Y);

            Func<T1, T2, TResult> SelfApplicableFunc = Fix(func);
            return SelfApplicableFunc;
        }
    }