如何使用其他参数更新Linq表达式
本文关键字：Linq 表达式 更新 参数 何使用 其他 | 更新日期: 2023-09-27 18:27:42
我有一个Linq表达式，它可能会根据某些条件进行更改。我想做的一个例子（空白部分我不确定）：
Expression<Func<Project, bool>> filter = (Project p) => p.UserName == "Bob";
if(showArchived)
{
// update filter to add && p.Archived
}
// query the database when the filter is built
IEnumerable<Project> projects = unitOfWork.ProjectRepository.Get(filter);
如何更新过滤器以添加任何额外的参数？
在检索到所有记录的那一刻，我使用Where来进一步过滤结果。然而，这会导致对数据库的查询超过严格必要的数量。
IEnumerable<Project> projects = unitOfWork.ProjectRepository.Get(filter);
if(showArchived)
{
projects = projects.Where(p => p.Archived);
}
Get方法使用GenericRepository模式：
public class GenericRepository<TEntity> where TEntity : class
{
internal ProgrammeDBContext context;
internal DbSet<TEntity> dbSet;
public GenericRepository(ProgrammeDBContext context)
{
this.context = context;
this.dbSet = context.Set<TEntity>();
}
public virtual IEnumerable<TEntity> Get(
Expression<Func<TEntity, bool>> filter = null,
Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
string includeProperties = "")
{
IQueryable<TEntity> query = dbSet;
if (filter != null)
{
query = query.Where(filter);
}
foreach (var includeProperty in includeProperties.Split
(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
query = query.Include(includeProperty);
}
if (orderBy != null)
{
return orderBy(query).ToList();
}
else
{
return query.ToList();
}
}
public virtual TEntity GetByID(object id)
{
return dbSet.Find(id);
}
public virtual void Insert(TEntity entity)
{
dbSet.Add(entity);
}
public virtual void Delete(object id)
{
TEntity entityToDelete = dbSet.Find(id);
Delete(entityToDelete);
}
public virtual void Delete(TEntity entityToDelete)
{
if (context.Entry(entityToDelete).State == EntityState.Detached)
{
dbSet.Attach(entityToDelete);
}
dbSet.Remove(entityToDelete);
}
public virtual void Update(TEntity entityToUpdate)
{
dbSet.Attach(entityToUpdate);
context.Entry(entityToUpdate).State = EntityState.Modified;
}
public virtual IEnumerable<TEntity> GetWithRawSql(string query, params object[] parameters)
{
return dbSet.SqlQuery(query, parameters).ToList();
}
}
更新
根据Marc Gravell和David B的以下代码创建了一些扩展方法，为我解决了问题
public static class LinqExtensionMethods
{
public static Expression<Func<T, bool>> CombineOr<T>(params Expression<Func<T, bool>>[] filters)
{
return filters.CombineOr();
}
public static Expression<Func<T, bool>> CombineOr<T>(this IEnumerable<Expression<Func<T, bool>>> filters)
{
if (!filters.Any())
{
Expression<Func<T, bool>> alwaysTrue = x => true;
return alwaysTrue;
}
Expression<Func<T, bool>> firstFilter = filters.First();
var lastFilter = firstFilter;
Expression<Func<T, bool>> result = null;
foreach (var nextFilter in filters.Skip(1))
{
var nextExpression = new ReplaceVisitor(lastFilter.Parameters[0], nextFilter.Parameters[0]).Visit(lastFilter.Body);
result = Expression.Lambda<Func<T, bool>>(Expression.OrElse(nextExpression, nextFilter.Body), nextFilter.Parameters);
lastFilter = nextFilter;
}
return result;
}
public static Expression<Func<T, bool>> CombineAnd<T>(params Expression<Func<T, bool>>[] filters)
{
return filters.CombineAnd();
}
public static Expression<Func<T, bool>> CombineAnd<T>(this IEnumerable<Expression<Func<T, bool>>> filters)
{
if (!filters.Any())
{
Expression<Func<T, bool>> alwaysTrue = x => true;
return alwaysTrue;
}
Expression<Func<T, bool>> firstFilter = filters.First();
var lastFilter = firstFilter;
Expression<Func<T, bool>> result = null;
foreach (var nextFilter in filters.Skip(1))
{
var nextExpression = new ReplaceVisitor(lastFilter.Parameters[0], nextFilter.Parameters[0]).Visit(lastFilter.Body);
result = Expression.Lambda<Func<T, bool>>(Expression.AndAlso(nextExpression, nextFilter.Body), nextFilter.Parameters);
lastFilter = nextFilter;
}
return result;
}
class ReplaceVisitor : ExpressionVisitor
{
private readonly Expression from, to;
public ReplaceVisitor(Expression from, Expression to)
{
this.from = from;
this.to = to;
}
public override Expression Visit(Expression node)
{
return node == from ? to : base.Visit(node);
}
}
}
如果我理解这个问题，那么很可能是问题所在：
IEnumerable<Project> projects = unitOfWork.ProjectRepository.Get(filter);
关于projects的任何工作都将使用Enumerable，而不是Queryable；可能应该是：
IQueryable<Project> projects = unitOfWork.ProjectRepository.Get(filter);
if(showArchived)
{
projects = projects.Where(p => p.Archived);
}
后者是可组合的，.Where应该如您所期望的那样工作，在将其发送到服务器之前构建一个限制性更强的查询。
您的另一个选择是在发送之前重写过滤器以组合：
using System;
using System.Linq.Expressions;
static class Program
{
static void Main()
{
Expression<Func<Foo, bool>> filter1 = x => x.A > 1;
Expression<Func<Foo, bool>> filter2 = x => x.B > 2.5;
// combine two predicates:
// need to rewrite one of the lambdas, swapping in the parameter from the other
var rewrittenBody1 = new ReplaceVisitor(
filter1.Parameters[0], filter2.Parameters[0]).Visit(filter1.Body);
var newFilter = Expression.Lambda<Func<Foo, bool>>(
Expression.AndAlso(rewrittenBody1, filter2.Body), filter2.Parameters);
// newFilter is equivalent to: x => x.A > 1 && x.B > 2.5
}
}
class Foo
{
public int A { get; set; }
public float B { get; set; }
}
class ReplaceVisitor : ExpressionVisitor
{
private readonly Expression from, to;
public ReplaceVisitor(Expression from, Expression to)
{
this.from = from;
this.to = to;
}
public override Expression Visit(Expression node)
{
return node == from ? to : base.Visit(node);
}
}
或者以方便使用的方式重新编写：
using System;
using System.Linq.Expressions;
static class Program
{
static void Main()
{
Expression<Func<Foo, bool>> filter = x => x.A > 1;
bool applySecondFilter = true;
if(applySecondFilter)
{
filter = Combine(filter, x => x.B > 2.5);
}
var data = repo.Get(filter);
}
static Expression<Func<T,bool>> Combine<T>(Expression<Func<T,bool>> filter1, Expression<Func<T,bool>> filter2)
{
// combine two predicates:
// need to rewrite one of the lambdas, swapping in the parameter from the other
var rewrittenBody1 = new ReplaceVisitor(
filter1.Parameters[0], filter2.Parameters[0]).Visit(filter1.Body);
var newFilter = Expression.Lambda<Func<T, bool>>(
Expression.AndAlso(rewrittenBody1, filter2.Body), filter2.Parameters);
return newFilter;
}
}
class Foo
{
public int A { get; set; }
public float B { get; set; }
}
class ReplaceVisitor : ExpressionVisitor
{
private readonly Expression from, to;
public ReplaceVisitor(Expression from, Expression to)
{
this.from = from;
this.to = to;
}
public override Expression Visit(Expression node)
{
return node == from ? to : base.Visit(node);
}
}
我认为您希望以这种方式组合过滤器：
var myFilters = new List<Expression<Func<Customer, bool>>>();
myFilters.Add(c => c.Name.StartsWith("B"));
myFilters.Add(c => c.Orders.Count() == 3);
if (stranded)
{
myFilters.Add(c => c.Friends.Any(f => f.Cars.Any())); //friend has car
}
Expression<Func<Customer, bool>> filter = myFilters.AndTheseFiltersTogether();
IEnumerable<Customer> thoseCustomers = Data.Get(filter);
此代码将允许您组合过滤器。
public static Expression<Func<T, bool>> OrTheseFiltersTogether<T>(params Expression<Func<T, bool>>[] filters)
{
return filters.OrTheseFiltersTogether();
}
public static Expression<Func<T, bool>> OrTheseFiltersTogether<T>(this IEnumerable<Expression<Func<T, bool>>> filters)
{
if (!filters.Any())
{
Expression<Func<T, bool>> alwaysTrue = x => true;
return alwaysTrue;
}
Expression<Func<T, bool>> firstFilter = filters.First();
var body = firstFilter.Body;
var param = firstFilter.Parameters.ToArray();
foreach (var nextFilter in filters.Skip(1))
{
var nextBody = Expression.Invoke(nextFilter, param);
body = Expression.OrElse(body, nextBody);
}
Expression<Func<T, bool>> result = Expression.Lambda<Func<T, bool>>(body, param);
return result;
}
public static Expression<Func<T, bool>> AndTheseFiltersTogether<T>(params Expression<Func<T, bool>>[] filters)
{
return filters.AndTheseFiltersTogether();
}
public static Expression<Func<T, bool>> AndTheseFiltersTogether<T>(this IEnumerable<Expression<Func<T, bool>>> filters)
{
if (!filters.Any())
{
Expression<Func<T, bool>> alwaysTrue = x => true;
return alwaysTrue;
}
Expression<Func<T, bool>> firstFilter = filters.First();
var body = firstFilter.Body;
var param = firstFilter.Parameters.ToArray();
foreach (var nextFilter in filters.Skip(1))
{
var nextBody = Expression.Invoke(nextFilter, param);
body = Expression.AndAlso(body, nextBody);
}
Expression<Func<T, bool>> result = Expression.Lambda<Func<T, bool>>(body, param);
return result;
}
这一切都取决于ProjectRepository.Get()的行为及其返回内容。通常的方法（例如，LINQ to SQL执行类似的操作）是，它返回一个IQueryable<T>，并允许您（除其他外）在以一个SQL查询的形式将其发送到服务器之前添加更多的Where()子句，其中包括所有的Where()子句。如果是这种情况，Mark的解决方案（使用IQuerybale<T>）将适用于您。
但是，如果Get()方法立即执行基于filter的查询，则需要将表达式中的整个过滤器传递给它。为此，您可以使用PredicateBuilder。
如果Get方法检索数据并返回内存对象，则可以执行
Expression<Func<Project, bool>> filter = (Project p) => p.UserName == "Bob";
if(showArchived) {
filter = (Project p) => p.UserName == "Bob" && p.Archived;
}
IEnumerable<Project> projects = unitOfWork.ProjectRepository.Get(filter);
编辑
只是为了指出。当您使用.ToList()方法时，它会枚举Queryable，即发出数据库请求。
去掉ToList()，一切都会好起来的。