C# Lambda 表达式学习之（四）：动态构建类似于 c => c.Age == 2 || c.Age == 5 || c => c.Age == 17 等等一个或多个 OrElse 的表达式

可能你还感兴趣：

1. C# Lambda 表达式学习之（一）：得到一个类的字段（Field）或属性（Property）名，强类型得到

2. C# Lambda 表达式学习之（二）：LambdaExpression 实战练习

3. 基于 Entity Framework FluentAPI 思想的强类型的 Lambda Expressions 实体映射

4. C# Lambda 表达式学习之（四）：动态构建类似于 c => c.Age == 2 || c.Age == 5 || c => c.Age == 17 等等一个或多个 OrElse 的表达式

直接贴代码了：

Post.cs

public class Post
{
    public int Id { get; set; }

    public string PostTitle { get; set; }

    public int BlogId { get; set; }

}

Program.cs

static void Main(string[] args)
{
    using (var context = new BloggingContext())
    {
        //下面是有数据2
        Expression<Func<Post, bool>> conditionExps3 =
            LambdaExtensionsIn.BuildPropertyInExpression<Post>("BlogId", new List<int?>() { , , null,  });
        var query14 = context.Set<Post>().Where(conditionExps3);

        Console.WriteLine();
    }
    Console.ReadLine();
}

LambdaExtensionsIn.cs

    public class LambdaExtensionsIn
    {
        /// <summary>
        /// 构建 属性A等于值1 或者 属性A等于值2 或者 属性A等于值3  等等一个或多个 OrElse  的表达式
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="propName"></param>
        /// <param name="values"></param>
        /// <returns></returns>
        public static Expression<Func<T, bool>> BuildPropertyInExpression<T>(string propName, IEnumerable values)
        {
            ParameterExpression x = Expression.Parameter(typeof(T), "x");
            LambdaExpression expr;
            var tempExp = BuildPropertyInExpressionCore(x, propName, values);
            if (tempExp == null)
            {
                expr = Expression.Lambda(LambdaExpression.Constant(false), x);
            }
            else
            {
                expr = Expression.Lambda(tempExp, x);
            }
            return (Expression<Func<T, bool>>)expr;
        }

        /// <summary>
        /// 构建属性等于单个值的表达式
        /// </summary>
        /// <param name="x"></param>
        /// <param name="propName"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        private static BinaryExpression BuildPropertyEqualsSingleValueExpression(ParameterExpression x, string propName, object id)
        {
            MemberExpression left = Expression.Property(x, propName);
            ConstantExpression right = Expression.Constant(id);
            return Expression.Equal(left, right);
        }

        /// <summary>
        /// 构建 属性A等于值1 或者 属性A等于值2 或者 属性A等于值3  等等一个或多个 OrElse  的表达式的核心
        /// </summary>
        /// <param name="x"></param>
        /// <param name="propName"></param>
        /// <param name="values"></param>
        /// <returns></returns>
        private static BinaryExpression BuildPropertyInExpressionCore(ParameterExpression x, string propName, IEnumerable values)
        {
            if (values == null)
            {
                throw new ArgumentNullException("values");
            }
            IEnumerator enumerator = values.GetEnumerator();
            int i = ;
            BinaryExpression binaryExp = null;
            while (enumerator.MoveNext())
            {
                object objValue = enumerator.Current;
                if (objValue == null)
                {
                    continue;
                }
                if (i == )
                {
                    binaryExp = BuildPropertyEqualsSingleValueExpression(x, propName, objValue);
                    i++;
                    continue;
                }
                binaryExp = Expression.OrElse(binaryExp, BuildPropertyEqualsSingleValueExpression(x, propName, objValue));
                i++;
            }
            return binaryExp;
        }
    }

运行截图：

01:

02:

谢谢浏览！