C#怎么动态创建lambda表达式

这篇文章主要讲解了“C#怎么动态创建lambda表达式”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“C#怎么动态创建lambda表达式”吧！

C#动态创建lambda表达式

代码如下：

           //querydata 是Dictionary<string,string> 放着要查询的属性名和相应的值            ParameterExpression pe = Expression.Parameter(typeof(Customer), "customer");//lambda表示式里的参数我这边是单参数            Expression left;//相当于 a=b 的 a            Expression right;//相当于a=b 的 b            Expression e;//作为最后形成的表达式的载体            //先放一个初始值后面被替换不然循环里不方便用                       left = Expression.Property(pe, typeof(Customer).GetProperty("name"));//Customer.name            right = Expression.Constant("巅峰白杨");//Constant方法设置属性对应的值            e = Expression.Equal(left, right);//Customer.name=="巅峰白杨"            //循环查询条件字典             foreach (var item in querydata)            {                if (!item.Value.ToString().Trim().Equals(""))                {                    left = Expression.Property(pe, typeof(SFC_Package).GetProperty(item.Key));                    right = Expression.Constant(item.Value);                    if (index == 0)                    {                        e = Expression.Equal(left, right);                        index++;                    }                    else                    {                        if (e != null)                        {                            Expression tempe;                            tempe = Expression.Equal(left, right);                            e = Expression.And(tempe, e);//加了一个&&连接两个判断                        }                    }                }            }                        IQueryable<Customer> queryableData = db.Customer.AsQueryable<Customer>();//将IEnumerable类型转成IQueryable                       //Where方法的lambda表达式            MethodCallExpression whereCallExpression = Expression.Call(            typeof(Queryable),            "Where",            new Type[] { queryableData.ElementType },            queryableData.Expression,            Expression.Lambda<Func<SFC_Package, bool>>(e, new ParameterExpression[] { pe }));            //OrderBy方法的lambda表达式 这边写的有点冗余第一次写不太习惯，想想重复了很多            var propertyinfo=typeof(Customer).GetProperty("Name");            Expression body=Expression.Property(pe,propertyinfo);            Type nametype=propertyinfo.PropertyType;            MethodCallExpression orderByCallExpression = Expression.Call(             typeof(Queryable),            "OrderBy",            new Type[] { queryableData.ElementType, nametype},//其实可以写成queryableData.ElementType.GetProperty("Name").PropertyType                        whereCallExpression,            Expression.Lambda(body, pe));            //使用已创建好的lambda表达式查询数据 ps:IQueryable和IEnumerable可以转换方便处理查询结果             IQueryable<SFC_Package> results = queryableData.Provider.CreateQuery<Customer>(orderByCallExpression);

网上还看到一种简单的多条件查询的方法，相当于

var data=db.Customer.Where(o=>o.name=="西门吹雪");data=data.Where(o=>o.sex="男神")

用循环来多次Where实现多条件查询，感觉可能会造成多次数据库查询，不过用在Linq to Object

上应该挺好的。

最后学习的动态创建lambda表达式地址 点击打开链接

Lambda表达式动态拼接生成工具类

    public static class LambdaUtil<T>    {        /// <summary>        /// lambda表达式:t=>true        /// </summary>        /// <returns></returns>        public static Expression<Func<T, bool>> True()        {            return t => true;        }         /// <summary>        /// lambda表达式:t=>false        /// </summary>        /// <returns></returns>        public static Expression<Func<T, bool>> False()        {            return t => false;        }         /// <summary>        /// lambda表达式:t=>t.propName        /// 多用于order排序        /// </summary>        /// <typeparam name="T">参数类型</typeparam>        /// <typeparam name="TKEy">返回类型</typeparam>        /// <param name="propName">属性名</param>        /// <returns></returns>        private static Expression<Func<T, TKey>> Order<TKey>(string propName)        {            // 创建节点参数t            ParameterExpression parameter = Expression.Parameter(typeof(T), "t");            // 创建一个属性            MemberExpression property = Expression.Property(parameter, propName);            // 生成lambda表达式            return Expression.Lambda<Func<T, TKey>>(property, parameter);        }         /// <summary>        /// lambda表达式:t=>t.propName==propValue        /// 多用于where条件        /// </summary>        /// <typeparam name="T">参数类型</typeparam>        /// <param name="propName">属性名称</param>        /// <param name="propValue">属性值</param>        /// <returns></returns>        public static Expression<Func<T, bool>> Equal(string propName, object propValue)        {            // 创建节点参数t            ParameterExpression parameter = Expression.Parameter(typeof(T), "t");            // 创建一个成员(字段/属性)            MemberExpression member = Expression.PropertyOrField(parameter, propName);            // 创建一个常数            ConstantExpression constant = Expression.Constant(propValue);            // 创建一个相等比较Expression            BinaryExpression binary = Expression.Equal(member, constant);            // 生成lambda表达式            return Expression.Lambda<Func<T, bool>>(binary, parameter);        }         /// <summary>        /// lambda表达式:t=>t.propName!=propValue        /// 多用于where条件        /// </summary>        /// <typeparam name="T">参数类型</typeparam>        /// <param name="propName">属性名称</param>        /// <param name="propValue">属性值</param>        /// <returns></returns>        public static Expression<Func<T, bool>> NotEqual(string propName, object propValue)        {            // 创建节点参数t            ParameterExpression parameter = Expression.Parameter(typeof(T), "t");            // 创建一个成员(字段/属性)            MemberExpression member = Expression.PropertyOrField(parameter, propName);            // 创建一个常数            ConstantExpression constant = Expression.Constant(propValue);            // 创建一个不相等比较Expression            BinaryExpression binary = Expression.NotEqual(member, constant);            // 生成lambda表达式            return Expression.Lambda<Func<T, bool>>(binary, parameter);        }         /// <summary>        /// lambda表达式:t=>t.propName&lt;propValue        /// 多用于where条件        /// </summary>        /// <typeparam name="T">参数类型</typeparam>        /// <param name="propName">属性名称</param>        /// <param name="propValue">属性值</param>        /// <returns></returns>        public static Expression<Func<T, bool>> LessThan(string propName, object propValue)        {            // 创建节点参数t            ParameterExpression parameter = Expression.Parameter(typeof(T), "t");            // 创建一个成员(字段/属性)            MemberExpression member = Expression.PropertyOrField(parameter, propName);            // 创建一个常数            ConstantExpression constant = Expression.Constant(propValue);            // 创建一个不相等比较Expression            BinaryExpression binary = Expression.LessThan(member, constant);            // 生成lambda表达式            return Expression.Lambda<Func<T, bool>>(binary, parameter);        }         /// <summary>        /// lambda表达式:t=>t.propName&lt;=propValue        /// 多用于where条件        /// </summary>        /// <typeparam name="T">参数类型</typeparam>        /// <param name="propName">属性名称</param>        /// <param name="propValue">属性值</param>        /// <returns></returns>        public static Expression<Func<T, bool>> LessThanOrEqual(string propName, object propValue)        {            // 创建节点参数t            ParameterExpression parameter = Expression.Parameter(typeof(T), "t");            // 创建一个成员(字段/属性)            MemberExpression member = Expression.PropertyOrField(parameter, propName);            // 创建一个常数            ConstantExpression constant = Expression.Constant(propValue);            // 创建一个不相等比较Expression            BinaryExpression binary = Expression.LessThanOrEqual(member, constant);            // 生成lambda表达式            return Expression.Lambda<Func<T, bool>>(binary, parameter);        }         /// <summary>        /// lambda表达式:t=>t.propName>propValue        /// 多用于where条件        /// </summary>        /// <typeparam name="T">参数类型</typeparam>        /// <param name="propName">属性名称</param>        /// <param name="propValue">属性值</param>        /// <returns></returns>        public static Expression<Func<T, bool>> GreaterThan(string propName, object propValue)        {            // 创建节点参数t            ParameterExpression parameter = Expression.Parameter(typeof(T), "t");            // 创建一个成员(字段/属性)            MemberExpression member = Expression.PropertyOrField(parameter, propName);            // 创建一个常数            ConstantExpression constant = Expression.Constant(propValue);            // 创建一个不相等比较Expression            BinaryExpression binary = Expression.GreaterThan(member, constant);            // 生成lambda表达式            return Expression.Lambda<Func<T, bool>>(binary, parameter);        }         /// <summary>        /// lambda表达式:t=>t.propName>=propValue        /// 多用于where条件        /// </summary>        /// <typeparam name="T">参数类型</typeparam>        /// <param name="propName">属性名称</param>        /// <param name="propValue">属性值</param>        /// <returns></returns>        public static Expression<Func<T, bool>> GreaterThanOrEqual(string propName, object propValue)        {            // 创建节点参数t            ParameterExpression parameter = Expression.Parameter(typeof(T), "t");            // 创建一个成员(字段/属性)            MemberExpression member = Expression.PropertyOrField(parameter, propName);            // 创建一个常数            ConstantExpression constant = Expression.Constant(propValue);            // 创建一个不相等比较Expression            BinaryExpression binary = Expression.GreaterThanOrEqual(member, constant);            // 生成lambda表达式            return Expression.Lambda<Func<T, bool>>(binary, parameter);        }         /// <summary>        /// lambda表达式:t=>{t.contains(propvalue1) ||...||t.contains(propvalueN)}        /// 多用于where条件        /// </summary>        /// <typeparam name="T">参数类型</typeparam>        /// <param name="propName">属性名称</param>        /// <param name="propValues">属性值数组</param>        /// <returns></returns>        public static Expression<Func<T, bool>> In(string propName, string[] propValues)        {            // 创建节点参数t            ParameterExpression parameter = Expression.Parameter(typeof(T), "t"); // left            // 创建一个成员(字段/属性)            MemberExpression member = Expression.PropertyOrField(parameter, propName);            // 创建一个常数            Expression constant = Expression.Constant(false);            // 创建一个方法            MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });            foreach (string item in propValues)            {                // 创建一个带参数方法Expression                MethodCallExpression methodCall = Expression.Call(member, method, Expression.Constant(item)); // right                // 连接参数方法                constant = Expression.Or(methodCall, constant);            }             // 生成lambda表达式            return Expression.Lambda<Func<T, bool>>(constant, new ParameterExpression[] { parameter });        }         /// <summary>        /// lambda表达式:t=>{!(t.contains(propvalue1) ||...||t.contains(propvalueN))}        /// 多用于where条件        /// </summary>        /// <typeparam name="T">参数类型</typeparam>        /// <param name="propName">属性名称</param>        /// <param name="propValues">属性值数组</param>        /// <returns></returns>        public static Expression<Func<T, bool>> NotIn(string propName, string[] propValues)        {            // 创建节点参数t            ParameterExpression parameter = Expression.Parameter(typeof(T), "t");            // 创建一个成员(字段/属性)            MemberExpression member = Expression.PropertyOrField(parameter, propName);            // 创建一个常数            Expression constant = Expression.Constant(false);            // 创建一个方法            MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });            foreach (string item in propValues)            {                // 创建一个带参数方法Expression                MethodCallExpression methodCall = Expression.Call(member, method, Expression.Constant(item)); // right                // 连接参数方法                constant = Expression.Or(methodCall, constant);            }             // 生成lambda表达式            return Expression.Lambda<Func<T, bool>>(Expression.Not(constant), new ParameterExpression[] { parameter });        }         /// <summary>        /// lambda表达式:t=>t.propName.Contains(propValue)        /// 多用于where条件        /// </summary>        /// <typeparam name="T">参数类型</typeparam>        /// <param name="propName">属性名称</param>        /// <param name="propValue">属性值</param>        /// <returns></returns>        public static Expression<Func<T, bool>> Contains(string propName, string propValue)        {            // 创建节点参数t            ParameterExpression parameter = Expression.Parameter(typeof(T), "t");            // 创建一个成员(字段/属性)            MemberExpression member = Expression.PropertyOrField(parameter, propName);            // 创建一个常数            ConstantExpression constant = Expression.Constant(propValue, typeof(string));            // 创建一个方法            MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });            // 创建一个带参数方法Expression            MethodCallExpression methodCall = Expression.Call(member, method, constant);            // 生成lambda表达式            return Expression.Lambda<Func<T, bool>>(methodCall, parameter);        }         /// <summary>        /// lambda表达式:t=>t.propName.Contains(propValue)        /// 多用于where条件        /// </summary>        /// <typeparam name="T">参数类型</typeparam>        /// <param name="propName">属性名称</param>        /// <param name="propValue">属性值</param>        /// <returns></returns>        public static Expression<Func<T, bool>> StartWith(string propName, string propValue)        {            // 创建节点参数t            ParameterExpression parameter = Expression.Parameter(typeof(T), "t");            // 创建一个成员(字段/属性)            MemberExpression member = Expression.PropertyOrField(parameter, propName);            // 创建一个常数            ConstantExpression constant = Expression.Constant(propValue, typeof(string));            // 创建一个方法            MethodInfo method = typeof(string).GetMethod("StartsWith", new[] { typeof(string) });            // 创建一个带参数方法Expression            MethodCallExpression methodCall = Expression.Call(member, method, constant);            // 生成lambda表达式            return Expression.Lambda<Func<T, bool>>(methodCall, parameter);        }         /// <summary>        /// lambda表达式:t=>t.propName.Contains(propValue)        /// 多用于where条件        /// </summary>        /// <typeparam name="T">参数类型</typeparam>        /// <param name="propName">属性名称</param>        /// <param name="propValue">属性值</param>        /// <returns></returns>        public static Expression<Func<T, bool>> EndsWith(string propName, string propValue)        {            // 创建节点参数t            ParameterExpression parameter = Expression.Parameter(typeof(T), "t");            // 创建一个成员(字段/属性)            MemberExpression member = Expression.PropertyOrField(parameter, propName);            // 创建一个常数            ConstantExpression constant = Expression.Constant(propValue, typeof(string));            // 创建一个方法            MethodInfo method = typeof(string).GetMethod("EndsWith", new[] { typeof(string) });            // 创建一个带参数方法Expression            MethodCallExpression methodCall = Expression.Call(member, method, constant);            // 生成lambda表达式            return Expression.Lambda<Func<T, bool>>(methodCall, parameter);        }         /// <summary>        /// lambda表达式:!(t=>t.propName.Contains(propValue))        /// 多用于where条件        /// </summary>        /// <typeparam name="T">参数类型</typeparam>        /// <param name="propName">属性名称</param>        /// <param name="propValue">属性值</param>        /// <returns></returns>        public static Expression<Func<T, bool>> NotContains(string propName, string propValue)        {            // 创建节点参数t            ParameterExpression parameter = Expression.Parameter(typeof(T), "t");            // 创建一个成员(字段/属性)            MemberExpression member = Expression.PropertyOrField(parameter, propName);            // 创建一个常数            ConstantExpression constant = Expression.Constant(propValue, typeof(string));            // 创建一个方法            MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });            // 创建一个带参数方法Expression            MethodCallExpression methodCall = Expression.Call(member, method, constant);            // 生成lambda表达式            return Expression.Lambda<Func<T, bool>>(Expression.Not(methodCall), parameter);        }         /// <summary>        /// lambda表达式:t=>{left and right}        /// 多用于where条件        /// </summary>        /// <param name="left">左侧条件</param>        /// <param name="right">右侧条件</param>        /// <returns></returns>        public static Expression<Func<T, bool>> And(Expression<Func<T, bool>> left, Expression<Func<T, bool>> right)        {            // 创建参数表达式            InvocationExpression invocation = Expression.Invoke(right, left.Parameters.Cast<Expression>());            // 创建and运算            BinaryExpression binary = Expression.And(left.Body, invocation);            // 生成lambda表达式            return Expression.Lambda<Func<T, bool>>(binary, left.Parameters);        }         /// <summary>        /// lambda表达式:t=>{left or right}        /// 多用于where条件        /// </summary>        /// <param name="left">左侧条件</param>        /// <param name="right">右侧条件</param>        /// <returns></returns>        public static Expression<Func<T, bool>> Or(Expression<Func<T, bool>> left, Expression<Func<T, bool>> right)        {            // 创建参数表达式            InvocationExpression invocation = Expression.Invoke(right, left.Parameters.Cast<Expression>());            // 创建or运算            BinaryExpression binary = Expression.Or(left.Body, invocation);            // 生成lambda表达式            return Expression.Lambda<Func<T, bool>>(binary, left.Parameters);        }    }

感谢各位的阅读，以上就是“C#怎么动态创建lambda表达式”的内容了，经过本文的学习后，相信大家对C#怎么动态创建lambda表达式这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是编程网，小编将为大家推送更多相关知识点的文章，欢迎关注！