动态创建 Lambda 表达式

首先我们看一个简单 Lambda 表达式的构成。

i => i > 5

在这个表达式中，"i" 被称为 Parameter，"i > 5" 是 Body。我们可以对 Body 进行更进一步的分解，那么 "i > 5" 分别包含参数(i)、操作符(>)以及一个常数(5)。所有这些通过特定顺序的组合，从而构建一个完整的 Lambda 表达式。

我们通过一些例子，来学习如何动态构建这些表达式。

例子1

            var list = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            //list = list.Where(i => i > 5);  //要实现的表达式

            // 创建参数 i
            var parameter = Expression.Parameter(typeof(int), "i");

            // 创建常量 5
            var constant = Expression.Constant(5);
            // 创建比较表达式 i > 5
            var body = Expression.GreaterThan(parameter, constant);

            // 获取Lambda表达式
            var lambda = Expression.Lambda<Func<int, bool>>(body, parameter);

            // 通过 Compile 方法获取 Delegate
            var _r = list.Where(lambda.Compile());

例子2

            var list = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            //list = list.Where(i => i > 5 && i <= 7); // 要实现的表达式

            // 创建参数 i
            var parameter = Expression.Parameter(typeof(int), "i");

            // 创建常量 5
            var constant1 = Expression.Constant(5);
            // 创建比较表达式 i > 5
            var left = Expression.GreaterThan(parameter, constant1);

            // 创建常量 7
            var constant2 = Expression.Constant(7);
            // 创建比较表达式 i <= 7
            var right = Expression.LessThanOrEqual(parameter, constant2);

            // 创建表达式 i > 5 && i <= 7
            var body = Expression.And(left, right);

            // 获取Lambda表达式
            var lambda = Expression.Lambda<Func<int, bool>>(body, parameter);

            // 通过 Compile 方法获取 Delegate
            var _r = list.Where(lambda.Compile());

例子3

            var list = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            //list = list.Where(i => (i > 5 && i <= 7) || (i == 3)); // 要实现的表达式

            // 创建参数 i
            var parameter = Expression.Parameter(typeof(int), "i");

            // 创建常量 5
            var constant1 = Expression.Constant(5);
            // 创建比较表达式 i > 5
            var left1 = Expression.GreaterThan(parameter, constant1);

            // 创建常量 7
            var constant2 = Expression.Constant(7);
            // 创建比较表达式 i <= 7
            var left2 = Expression.LessThanOrEqual(parameter, constant2);

            // 创建常量 3
            var constant3 = Expression.Constant(3);
            // 创建比较表达式 i == 3
            var right = Expression.Equal(parameter, constant3);

            //创建表达式 i>5 && i<=7
            var left = Expression.And(left1, left2);

            //创建表达式 (i > 5 && i <= 7) || (i == 3)
            var body = Expression.Or(left, right);

            // 获取Lambda表达式
            var lambda = Expression.Lambda<Func<int, bool>>(body, parameter);

            // 通过 Compile 方法获取 Delegate
            var _r = list.Where(lambda.Compile());

例子4

            var list = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            //var res = list.Select(i => i % 2 == 0 ? i : 0); // 要实现的表达式

            // 创建参数 i
            var parameter = Expression.Parameter(typeof(int), "i");

            //创建常量 2
            var constant1 = Expression.Constant(2);
            // 创建表达式 i % 2
            var left1 = Expression.Modulo(parameter, constant1);

            //创建常量 0
            var constant2 = Expression.Constant(0);
            // 创建表达式 (i % 2) == 0
            var left = Expression.Equal(left1, constant2);

            // 创建表达式 i % 2 == 0 ? i : 0
            var body = Expression.Condition(left, parameter, Expression.Constant(0));

            var lambda = Expression.Lambda<Func<int, int>>(body, parameter);
            var _r = list.Select(lambda.Compile());

例子5

            var list = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            //list.ForEach(i => Console.WriteLine(i)); // 要实现的表达式

            // 创建参数i
            var parameter = Expression.Parameter(typeof(int), "i");

            // 获取 Console.WriteLine MethodInfo
            MethodInfo method = typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) });

            // 创建表达式 Console.WriteLine(i)
            var call = Expression.Call(method, parameter);

            var lambda = Expression.Lambda<Action<int>>(call, parameter);
            list.ForEach(lambda.Compile());

 例子6

            var list = new List<string> { "J", "K", "L", "UI", "DAL" };
            //var res = list.Where(s => s.Length > 1); // 要实现的表达式

            // 创建参数 i
            var parameter = Expression.Parameter(typeof(string), "s");

            //创建常量 1
            var constant = Expression.Constant(1);
            // 创建属性表达式 s.Length
            var left = Expression.Property(parameter, "Length");

            //创建表达式 s.Length > 1
            var body = Expression.GreaterThan(left, constant);

            var lambda = Expression.Lambda<Func<string, bool>>(body, parameter);
            var _r = list.Where(lambda.Compile());

动态创建表达式树就到此为止啦！