C#Expression表达式树(lambda)的使用——Parameter、Property、Call、构建Select、构建Where

1、定义参数(Parameter)、访问属性(Property)

private static void Main(string[] args)
{
    //1.定义参数(Parameter)、访问属性(Property)
    //定义表达式树中的参数或变量(linq表达式参数的名称，如m=>m.Name中的m)
    var param = Expression.Parameter(typeof(List<string>), "m");
    //创建对象中可访问的成员属性
    var member = Expression.Property(param, "Count");
    //创建编译时已知委托类型的lambda表达式(Func<List<string>, int>:参数类型为List<string>,返回类型为int)
    var lambda = Expression.Lambda<Func<List<string>, int>>(member, param);
    //委托执行lambda表达式
    int result = lambda.Compile()(new List<string> { "a1", "b1", "c1", "d1" });
    Console.WriteLine(result);
    Console.ReadKey();
}

2、调用方法(Call)

public class UserInfo
{
    public string Id { get; set; }
    public string Name { get; set; }
    public bool SP_IsDelete { get; set; }
    public UserInfo()
    {
    }
}

private static void Main(string[] args)
{
    //2.调用方法或函数(Call)
    //(1).调用静态方法
    //var method = Expression.Call(
    //    null, //static方法实例为null
    //    typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }), //调用的方法名和参数类型
    //    Expression.Constant("调用WriteLine方法")); //传入参数值
    //var lambda = Expression.Lambda<Action>(method); //创建lambda表达式
    //lambda.Compile(); //执行lambda表达式
    //(2).调用实例方法
    var param = Expression.Parameter(typeof(UserInfo), "m"); //定义变量           
    var method = Expression.Call(
        param, //实例
        typeof(UserInfo).GetMethod("Print", new Type[] { typeof(string) }), //调用的方法名和参数类型
        Expression.Constant("打印出来！！！")); //传入参数值           
    var lambda = Expression.Lambda<Action<UserInfo>>(method, param); //创建lambda表达式
    lambda.Compile()(new UserInfo()); //执行lambda表达式
    Console.ReadKey();
}

3、实例化引用类型

private static void Main(string[] args)
{
    //3.实例化引用类型
    //调用构造函数
    var cons = Expression.New(typeof(UserInfo));
    //给UserInfo对象的属性Name赋值
    var binding = Expression.Bind(typeof(UserInfo).GetMember("Name")[0], Expression.Constant("张三"));
    //实例化UserInfo对象
    var newEnt = Expression.MemberInit(cons, new List<MemberBinding>() { binding });
    Console.ReadKey();
}

4、定义集合变量、初始化、添加元素

private static void Main(string[] args)
{
    //4.定义集合变量、初始化、添加元素
    var listAdd = typeof(List<string>).GetMethod("Add");
    var add1 = Expression.ElementInit(listAdd, Expression.Constant("a"));
    var add2 = Expression.ElementInit(listAdd, Expression.Constant("b"));
    var add3 = Expression.ElementInit(listAdd, Expression.Constant("666"));
    var list = Expression.New(typeof(List<string>));
    //初始化值
    var setList = Expression.ListInit(list, add1, add2, add3);
    //输出信息
    Console.WriteLine(setList.ToString());
    //访问属性
    var member = Expression.Property(setList, "Count");
    var lambda = Expression.Lambda<Func<int>>(member);
    int result = lambda.Compile()();
    Console.WriteLine(result);
    Console.ReadKey();
}

5、实战：过滤多字段(lambda表达式构建Select)

public static IQueryable<T> FilterFields<T>(this IQueryable<T> query, List<string> fields, string paramName = "m")
{
    //定义表达式树中的变量(linq表达式参数的名称，如m=>m.Name中的m)
    var param = Expression.Parameter(typeof(T), paramName);
    /* typeof(T).GetProperty(m):获取成员属性信息
     * Expression.Property(param, m):对象T中的成员属性
     * Expression.Bind:给字段或属性初始化并赋值
     */
    var bindings = fields.Select(m => Expression.Bind(typeof(T).GetProperty(m), Expression.Property(param, m)));
    /* Expression.New(typeof(T)):调用无参构造函数
     * Expression.MemberInit:实例化对象并为属性设置值
     */
    var newEnt = Expression.MemberInit(Expression.New(typeof(T)), bindings);
    //创建lambda表达式(Func<T,T>:参数类型为T,返回类型为T)
    var lambda = Expression.Lambda<Func<T, T>>(newEnt, param);
    return query.Select(lambda);
}

6、实战：字段条件筛选(lambda表达式构建Where)​​​​​​​

public static IQueryable<T> NoDelete<T>(this IQueryable<T> query, string fieldName = "IsDelete", string paramName = "m")
{
    //创建表达式中的参数或变量(如m=>m.IsDelete==false中的m)
    var param = Expression.Parameter(typeof(T), paramName);
    //创建表达式中左边的属性(如m=>m.IsDelete==false中的m.IsDelete)
    var left = Expression.Property(param, fieldName);
    //创建表达式中右边的常量表达式(如m=>m.IsDelete==false中的false)
    var right = Expression.Constant(false);
    //创建成二元运算符表达式(如m=>m.IsDelete==false中的==)
    var body = Expression.Equal(left, right);
    //拼接成筛选条件
    return query.Where(Expression.Lambda<Func<T, bool>>(body, param));
}