none
Expression linq表达式如何在外面封装? RRS feed

  • 问题

  •   List<string> vars ;

    vars.Foreach(v=>{

      //这边想封装一个 或的表达式

    类似:

     lembda = d => d.VarietyId.Contains(v1) || d.VarietyId.Contains(v2) 

    })

      query = query.Where(lembda);

    例如上面 的怎么写啊?谢谢

    2017年12月14日 7:30

全部回复

  • 参考这个例子

    var expression = LinqExtensions.True<DataItemDetailEntity>();
                expression = expression.And(t => t.ItemValue == itemValue).And(t => t.ItemId == itemId);
                if (!string.IsNullOrEmpty(keyValue))
                {
                    expression = expression.And(t => t.ItemDetailId != keyValue);
                }

    从GUI传入参数,转化为表达式

      var expression = LinqExtensions.True<CodeRuleEntity>();
                var queryParam = queryJson.ToJObject();
                //查询条件
                if (!queryParam["condition"].IsEmpty() && !queryParam["keyword"].IsEmpty())
                {
                    string condition = queryParam["condition"].ToString();
                    string keyword = queryParam["keyword"].ToString();
                    switch (condition)
                    {
                        case "EnCode":              //对象编号
                            expression = expression.And(t => t.EnCode.Contains(keyword));
                            break;
                        case "FullName":            //对象名称
                            expression = expression.And(t => t.FullName.Contains(keyword));
                            break;
                        default:
                            break;
                    }
                }


    专注于.NET ERP/CRM开发框架,C/S架构,SQL Server + ORM(LLBL Gen Pro) + Infragistics WinForms



    2017年12月15日 0:54
  • using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Linq.Expressions;
    using System.Reflection;
    using System.Text;

    namespace EnterpriseSolution.Framework.Extension
    {
        /// <summary>
        /// Enables the efficient, dynamic composition of query predicates.
        /// </summary>
        public static class LinqExtensions
        {
            public static Expression Property(this Expression expression, string propertyName)
            {
                return Expression.Property(expression, propertyName);
            }
            public static Expression AndAlso(this Expression left, Expression right)
            {
                return Expression.AndAlso(left, right);
            }
            public static Expression Call(this Expression instance, string methodName, params Expression[] arguments)
            {
                return Expression.Call(instance, instance.Type.GetMethod(methodName), arguments);
            }
            public static Expression GreaterThan(this Expression left, Expression right)
            {
                return Expression.GreaterThan(left, right);
            }
            public static Expression<T> ToLambda<T>(this Expression body, params  ParameterExpression[] parameters)
            {
                return Expression.Lambda<T>(body, parameters);
            }
            public static Expression<Func<T, bool>> True<T>() { return param => true; }
            public static Expression<Func<T, bool>> False<T>() { return param => false; }
            /// <summary>
            /// 组合And
            /// </summary>
            /// <returns></returns>
            public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
            {
                return first.Compose(second, Expression.AndAlso);
            }
            /// <summary>
            /// 组合Or
            /// </summary>
            /// <returns></returns>
            public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
            {
                return first.Compose(second, Expression.OrElse);
            }

            /// <summary>
            /// Combines the first expression with the second using the specified merge function.
            /// </summary>
            static Expression<T> Compose<T>(this Expression<T> first, Expression<T> second, Func<Expression, Expression, Expression> merge)
            {
                var map = first.Parameters
                    .Select((f, i) => new { f, s = second.Parameters[i] })
                    .ToDictionary(p => p.s, p => p.f);
                var secondBody = ParameterRebinder.ReplaceParameters(map, second.Body);
                return Expression.Lambda<T>(merge(first.Body, secondBody), first.Parameters);
            }

            /// <summary>
            /// ParameterRebinder
            /// </summary>
            private class ParameterRebinder : ExpressionVisitor
            {
                /// <summary>
                /// The ParameterExpression map
                /// </summary>
                readonly Dictionary<ParameterExpression, ParameterExpression> map;
                /// <summary>
                /// Initializes a new instance of the <see cref="ParameterRebinder"/> class.
                /// </summary>
                /// <param name="map">The map.</param>
                ParameterRebinder(Dictionary<ParameterExpression, ParameterExpression> map)
                {
                    this.map = map ?? new Dictionary<ParameterExpression, ParameterExpression>();
                }
                /// <summary>
                /// Replaces the parameters.
                /// </summary>
                /// <param name="map">The map.</param>
                /// <param name="exp">The exp.</param>
                /// <returns>Expression</returns>
                public static Expression ReplaceParameters(Dictionary<ParameterExpression, ParameterExpression> map, Expression exp)
                {
                    return new ParameterRebinder(map).Visit(exp);
                }
                /// <summary>
                /// Visits the parameter.
                /// </summary>
                /// <param name="p">The p.</param>
                /// <returns>Expression</returns>
                protected override Expression VisitParameter(ParameterExpression p)
                {
                    ParameterExpression replacement;

                    if (map.TryGetValue(p, out replacement))
                    {
                        p = replacement;
                    }
                    return base.VisitParameter(p);
                }
            }
        }
    }

    专注于.NET ERP/CRM开发框架,C/S架构,SQL Server + ORM(LLBL Gen Pro) + Infragistics WinForms


    2017年12月15日 0:57