Lambda动态条件查询

using System;
using System.Linq;
using System.Linq.Expressions;
using System.Collections.Generic;

    public static class PredicateBuilder
    {
        public static Expression<Func<T, bool>> True<T>() { return f => true; }
        public static Expression<Func<T, bool>> False<T>() { return f => false; }

        public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr1,
                                                            Expression<Func<T, bool>> expr2)
        {
            var invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast<Expression>());
            return Expression.Lambda<Func<T, bool>>
                  (Expression.OrElse(expr1.Body, invokedExpr), expr1.Parameters);
        }

        public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr1,
                                                             Expression<Func<T, bool>> expr2)
        {
            var invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast<Expression>());
            return Expression.Lambda<Func<T, bool>>
                  (Expression.AndAlso(expr1.Body, invokedExpr), expr1.Parameters);
        }

        public IList<Memo> GetMemoList(string department, bool includePublic)
        {
            var filterExpression = PredicateBuilder.True<Memo>();
            filterExpression = filterExpression.And(x => x.ID > 0);

            if (department != "")
            {
                filterExpression = filterExpression.And(x => x.Department == department);
            }

            if (includePublic)
            {
                var orExpression = PredicateBuilder.False<Memo>();
                orExpression = orExpression.Or(x => x.IsPublic == true);
                filterExpression = filterExpression.Or(orExpression);
            }

            return db.Memo.Where(filterExpression.Compile())
                .OrderByDescending(x => x.IsTop)
                .ThenByDescending(x => x.ID).ToList();
        }

Ref:Dynamically Composing Expression Predicates