9.3 表达式树

9.3.2 将表达式树编译成委托

    class Program
    {
        static void Main(string[] args)
        {
            Expression firstArg = Expression.Constant(2);
            Expression secondArg = Expression.Constant(3);
            Expression add = Expression.Add(firstArg, secondArg);

            Func<int> compiled = Expression.Lambda<Func<int>>(add).Compile();
            Console.WriteLine(compiled());

            Console.ReadKey();
        }
    }

 9.3.3 将C# Lambda表达式转换成表达式树

   class Program
    {
        static void Main(string[] args)
        {
            Expression<Func<int>> return5 = () => 5;
            Func<int> compiled1 = return5.Compile();
            Console.WriteLine(compiled1());

            //=====================================

            Expression<Func<string, string, bool>> expression = (x, y) => x.StartsWith(y);
            var compield2 = expression.Compile();
            Console.WriteLine(compield2("First", "Second"));
            Console.WriteLine(compield2("First", "Fir"));

            //=====================================

            MethodInfo method = typeof(string).GetMethod("StartsWith", new[] { typeof(string) });
            var target = Expression.Parameter(typeof(string), "x");
            var methodArg = Expression.Parameter(typeof(string), "y");
            Expression[] methodArgs = new[] { methodArg }; 

            Expression call = Expression.Call(target, method, methodArgs);

            var lambdaParameters = new[] { target, methodArg };
            var lambda = Expression.Lambda<Func<string, string, bool>>(call, lambdaParameters);

            var compild3 = lambda.Compile();
            Console.WriteLine(compild3("First", "Second"));
            Console.WriteLine(compild3("First", "Fir"));

            Console.ReadKey();
        }
    }

 9.4.1 改变的起因：精简泛型方法调用

    class Program
    {
        static void Main(string[] args)
        {
            PrintConvert("I'm a string", x => x.Length);

            Console.ReadKey();
        }
        static void PrintConvert<TInput, TOutPut>(TInput inPut, Converter<TInput, TOutPut> convert)
        {
            Console.WriteLine(convert(inPut));
        }
    }

9.4.2 推断匿名函数的返回类型

    class Program
    {
        delegate T MyFunc<T>();
        static void Main(string[] args)
        {
            WriteResult(() => 5);

            WriteResult(delegate
            {
                if (DateTime.Now.Hour < 12)
                {
                    return 10;
                }
                else
                {
                    return new object();
                }
            });
            Console.ReadKey();
        }
        static void WriteResult<T>(MyFunc<T> func)
        {
            Console.WriteLine(func());
        }
    }

 9.4.3 分两个阶段进行的类型推断

    class Program
    {
        static void Main(string[] args)
        {
            ConvertTwice("I'm a string", x => x.Length, y => Math.Sqrt(y));

            Console.ReadKey();
        }
        static void ConvertTwice<TInput, TMiddle, TOutPut>(TInput inPut, Converter<TInput, TMiddle> firstConversion, Converter<TMiddle, TOutPut> secondConversion)
        {
            TMiddle middle = firstConversion(inPut);
            TOutPut outPut = secondConversion(middle);
            Console.WriteLine(outPut);
        }
    }

 9.4.4 选择正确的被重载的方法

    class Program
    {
        static void Main(string[] args)
        {
            Write(1);
            Write(1d);
            Write((double)1);

            Console.ReadKey();
            /*
            int 1
            double 1
            double 1
             */
        }
        static void Write(int x)
        {
            Console.WriteLine("int " + x);
        }
        static void Write(double x)
        {
            Console.WriteLine("double " + x);
        }
    }