表达式树练习

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
public class Test
{
static public void Main()
{
#region
//x=>x+1
//var param = Expression.Parameter(typeof(int), “x”);//x
//var con = Expression.Constant(1); //1
//var ex = Expression.Add(param, con); //x+1
//var lambda = Expression.Lambda<Func<int, int>>(ex,param);//x=>x+1
//var func =lambda.Compile();
#endregion

    #region
    //(a,b)=>a*3+b*4
    //var param1 = Expression.Parameter(typeof(int), "a");//a
    //var cons1 = Expression.Constant(3);                 //3
    //var lambda1 = Expression.Multiply(param1, cons1);   //3*a

    //var param2 = Expression.Parameter(typeof(int), "b");//b
    //var cons2 = Expression.Constant(4);                 //4
    //var lambda2 = Expression.Multiply(param2, cons2);   //4*b

    //var lambda3 = Expression.Add(lambda1, lambda2);     //3*a+4*b

    //var lambda = Expression.Lambda<Func<int, int,int>>(lambda3, param1, param2);
    //var func = lambda.Compile();
    #endregion

    #region
    //(a, b, c, d, e) => ((a + b) * (c - d)) % e

    //var a = Expression.Parameter(typeof(double), "a");
    //var b = Expression.Parameter(typeof(double), "b");
    //var lambda1 = Expression.Add(a, b);

    //var c = Expression.Parameter(typeof(double), "c");
    //var d = Expression.Parameter(typeof(double), "d");
    //var lambda2 = Expression.Subtract(c, d);
    //var lambda3 = Expression.Multiply(lambda1, lambda2);

    //var e = Expression.Parameter(typeof(double), "e");
    //var lambda4 = Expression.Modulo(lambda3, e);

    //var lambda = Expression.Lambda<Func<double,double,double,double,double,double>>(lambda4, a, b, c, d, e);
    //var func = lambda.Compile()(2, 3, 8, 5, 7);
    #endregion

    #region
    //var myClass = new MyClass(100);

    //NewExpression a = Expression.New(typeof(MyClass).GetConstructor(new Type[] { typeof(int)}), Expression.Constant(100));
    //var lambda = Expression.Lambda<Func<MyClass>>(a);
    //var func = lambda.Compile();
    //Console.WriteLine(lambda);
    Console.WriteLine(func);
    //Console.Read();
    #endregion


    #region
    ///e=>e.MyProperty

    //var e = Expression.Parameter(typeof(MyClass), "e");
    //var property = Expression.Property(e, nameof(MyClass.MyProperty));
    //var lambda = Expression.Lambda<Func<MyClass, string>>(property, e);
    //var func = lambda.Compile();
    //Console.WriteLine(lambda);
    Console.WriteLine(func);
    //Console.Read();
    #endregion


    #region
    ///e=>e.List=new List<string>(){"sdf"}

    //var new = Expression.New(typeof(MyClass).GetConstructor(new Type[] { typeof(int) }), Expression.Constant(100));
    //var lam = Expression.Lambda<Func<MyClass>>(new);
    //var myClass = lam.Compile()();

    //var e = Expression.Parameter(typeof(MyClass), "e");
    //var list = Expression.Property(e, nameof(MyClass.List));     //e.list
    //var sdf = Expression.Constant(new List<string>() { "sdf" }); //"sdf"
    //var assin = Expression.Assign(list, sdf);                    //e.list                         
    //var lambda =Expression.Lambda<Action<MyClass>>(assin, e);

    //Console.WriteLine(lambda);
    Console.WriteLine(func);
    //Console.Read();
    #endregion


    #region
    //e => e.GetHashCode();

    //var e = Expression.Parameter(typeof(MyClass), "e");        
    //var method = typeof(MyClass).GetMethod(nameof(GetHashCode)); //.GetHashCode
    //var call = Expression.Call(e,method);                        //e.GetHashCode
    //var lambda = Expression.Lambda<Func<MyClass,int>>(call, e);
    #endregion

    #region
    //e=>e.SayHello("你好")

    //var e = Expression.Parameter(typeof(MyClass), "e");
    //var method = typeof(MyClass).GetMethod(nameof(MyClass.SayHello),new Type[] { typeof(string)});//.sayHello()
    //var call = Expression.Call(e, method,Expression.Constant("你好"));
    //var lambda = Expression.Lambda<Func<MyClass, string>>(call, e);
    //var func = lambda.Compile();
    #endregion

    #region
    //e=>e.List.Contains("s")
    
    //var e = Expression.Parameter(typeof(MyClass), "e");
    //var list = Expression.Property(e, nameof(MyClass.List));//e.list
    //var method = typeof(Enumerable).GetMethods().FirstOrDefault(info => info.GetParameters().Length >= 2 && info.Name == "Contains").MakeGenericMethod(typeof(string));//.contains()
    //var call = Expression.Call(null, method,list, Expression.Constant("s"));//e.list.contains("s")
    //var lambda = Expression.Lambda<Func<MyClass, bool>>(call, e);
    #endregion

    #region
    //e => e.List.Any(s => s.Contains("a"))

    //var e = Expression.Parameter(typeof(MyClass), "e");//e
    //var s = Expression.Parameter(typeof(string),"s");  //s
    //var method = Expression.Call(s, typeof(string).GetMethod("Contains", new Type[] { typeof(string) }), Expression.Constant("a"));//.contain
    //var containLambda = Expression.Lambda<Func<string, bool>>(method, s);//s=>s.Contains("a")
    //var any = typeof(Enumerable).GetMethods().FirstOrDefault(info => info.GetParameters().Length >= 2 && info.Name == "Any").MakeGenericMethod(typeof(string));//.Ang
    //var list = Expression.Property(e, nameof(MyClass.List));//e.list
    //var call = Expression.Call(null, any, list, containLambda);
    //var lambda = Expression.Lambda<Func<MyClass,bool>>(call,e);
    #endregion

    #region
    //x => x > 60 ? "及格" : "不及格"
    
    //var x = Expression.Parameter(typeof(int), "x");
    //var greater = Expression.GreaterThan(x, Expression.Constant(60));
    //var condition = Expression.Condition(greater, Expression.Constant("及格"), Expression.Constant("不及格"));
    //var lambda = Expression.Lambda<Func<int, string>>(condition, x);
    #endregion


    #region

    //e => e.MyBool ? "真的" : "假的";
    
    //var e = Expression.Parameter(typeof(MyClass), "e");
    //var property = Expression.Property(e, nameof(MyClass.MyBool));
    //var condition = Expression.Condition(property, Expression.Constant("真的"), Expression.Constant("假的"));
    //var lambda = Expression.Lambda<Func<MyClass, string>>(condition, e);

    #endregion

    #region
    //null值表达式e => e.MyProperty ?? "s"
    
    //var e = Expression.Parameter(typeof(MyClass), "e");
    //var property = Expression.Property(e, nameof(MyClass.MyProperty));
    //var coalesce = Expression.Coalesce(property, Expression.Constant("s"));
    //var lambda = Expression.Lambda<Func<MyClass, string>>(coalesce, e);
    #endregion

    #region

    Convert.ToInt32(x)
    
    //var convert = Expression.Convert(Expression.Constant(10.2), typeof(int));
    //var lambda = Expression.Lambda<Func<int>>(convert);
    #endregion

    #region
    //数组对象表达式
    
    //var array = Expression.NewArrayBounds(typeof(string), Expression.Constant(5));
    //var lambda = Expression.Lambda<Func<string[]>>(array);
    #endregion


    #region
    //m => m.MyProperty.Contains("ldqk") || m.List.Any(s => s.Length > 1 && s.Contains("a"))
    
    //var s = Expression.Parameter(typeof(string), "s");
    //var length = Expression.Property(s, nameof(string.Length));//s.Length
    //var gt10 = Expression.GreaterThan(length, Expression.Constant(1));//s.Length>1
    //var aContain = typeof(string).GetMethod("Contains",new Type[] { typeof(string)});//Contains()
    //var anyContains = Expression.Call(s, aContain, Expression.Constant("a"));//s.Contains("a")
    //var and = Expression.AndAlso(gt10, anyContains); //s.length>1&&s.contains("a')
    //var anyLambda = Expression.Lambda<Func<string, bool>>(and, s);//s=>s.length>1&&s.Contains("a")


    //var m = Expression.Parameter(typeof(MyClass), "m");//m
    //var property = Expression.Property(m, nameof(MyClass.MyProperty));
    //var contain = typeof(string).GetMethod("Contains",new Type[] { typeof(string)});
    //var containWhat = Expression.Call(property, contain, Expression.Constant("ldqk"));//m.MyProperty.Contains("ldqk")

    //var list = Expression.Property(m, nameof(MyClass.List));//m.list
    //var any = typeof(Enumerable).GetMethods().FirstOrDefault(info => info.GetParameters().Length >= 2 && info.Name == "Any").MakeGenericMethod(typeof(string));
    //var anyWhat = Expression.Call(null, any,list,anyLambda);//m.list.any(lambda1)

    //var orElse = Expression.OrElse(containWhat, anyWhat);

    //var lambda = Expression.Lambda<Func<MyClass, bool>>(orElse, m);
    #endregion

    #region
    //s=>s.List.Select(e => e.Length).OrderBy(x=>x).FirstOrDefault() > 1

    //var s = Expression.Parameter(typeof(MyClass), "s");//s
    //var list = Expression.Property(s, nameof(MyClass.List));//s.List
    //var selectMethod = typeof(Enumerable).GetMethods().FirstOrDefault(info => info.GetParameters().Length == 2 && info.Name == "Select").MakeGenericMethod(typeof(string),typeof(int));//.Select

    //var e = Expression.Parameter(typeof(string), "e");//e
    //var length = Expression.Property(e, "Length");//e.Length
    //var selectLambda = Expression.Lambda<Func<string, int>>(length, e);//e=>e.length

    //var selectCall = Expression.Call(null, selectMethod,list, selectLambda);//s.List.Select(e=>e.Length)

    //var x = Expression.Parameter(typeof(int), "x");//x
    //var orderLambda = Expression.Lambda<Func<int, int>>(x, x); //x=>x

    //var orderMethod = typeof(Enumerable).GetMethods().FirstOrDefault(info => info.GetParameters().Length >= 2 && info.Name == "OrderBy").MakeGenericMethod(typeof(int), typeof(int));

    //var orderCall = Expression.Call(null, orderMethod, selectCall, orderLambda); // //s.List.Select(e => e.Length).OrderBy(x=>x)

    //var firstMethod = typeof(Enumerable).GetMethods().FirstOrDefault(info => info.GetParameters().Length >= 1 && info.Name == "FirstOrDefault").MakeGenericMethod(typeof(int));

    //var firstCall = Expression.Call(null, firstMethod, orderCall);

    //var greater = Expression.GreaterThan(firstCall, Expression.Constant(1));
    //var lambda = Expression.Lambda<Func<MyClass, bool>>(greater, s);

    #endregion





    //Console.WriteLine(lambda);
    Console.WriteLine(func);
    //Console.Read();

}
public class MyClass
{
    public MyClass(int num)
    {
        Number = num;
    }
    public bool MyBool { get; set; }
    public int Number { get; set; }
    public string MyProperty { get; set; }
    public List<string> List { get; set; }
    public string SayHello(string s)
    {
        return s + DateTime.Now.ToString("yyyy-MM-dd");
    }
}

}