日本免费高清视频-国产福利视频导航-黄色在线播放国产-天天操天天操天天操天天操|www.shdianci.com

學無先后，達者為師

網站首頁 編程語言 正文

C#如何動態創建lambda表達式_C#教程

作者：巔峰白羊 ? 更新時間： 2023-06-18 編程語言

C#動態創建lambda表達式

近日在使用了一下EF框架，在做多條件where查詢的時候不知道怎么做，網上找了找，一開始用context.Database.SqlQuery<T>方法寫sql語句，之后遇到了SqlParamterCollection已在另一定義的問題，找了一下，大概知道什么問題，覺得用EF真的有點不方便，還不如用Dapper開發效率快，之后又在網上搜了搜關鍵字EF框架多條件Where查詢就打開了新世界的大門。

動態創建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);
        }
    }

總結

原文鏈接：https://blog.csdn.net/qq_33961062/article/details/80223101

  • 上一篇：沒有了
  • 下一篇：沒有了
欄目分類
最近更新