我有以下方法。我使用匿名投影来过滤EF所做的includes。我从这篇博客文章中学到了这个方法：http://thedatafarm.com/data-access/use-projections-and-a-repository-to-fake-a-filtered-eager-load/
public IEnumerable<Entities.Nutrient> FindAllForSpecificLanguage(bool overridePossibleLogicalDelete)
{
using (var context = CreateObjectContext())
{
context.ContextOptions.LazyLoadingEnabled = false;
Entities.Nutrient[] result;
var list = context.Nutrients
.Select(nut => new
{
Entity = nut,
Descriptions = nut.Descriptions.Where(desc => desc.LanguageCode.Equals(DataLanguageContext.Current.DataLanguageCode))
}).ToList(); //perform query
var resultList = list
.Select(entity => entity.Entity);
return resultList;
}
}
这种方法应该构建在所有服务中（api支持大约30种语言，目前我们有很多DB开销…）。我试图以一种通用的方式构建它，但我在表达树方面非常缺乏经验。我以为我完全重新创建了这个函数，但我缺少了一些东西，因为它不起作用。这就是我目前所拥有的：
public virtual IEnumerable<TEntity> FindAllForSpecificLanguage(bool overridePossibleLogicalDelete, Expression<Func<TEntity, IEnumerable<object>>> selectEntityDescriptions)
{
using (var context = CreateObjectContext())
{
context.ContextOptions.LazyLoadingEnabled = false;
ObjectQuery<TEntity> queryObjectSet = GetObjectSet(context);
TEntity[] result;
Type anonType = new {Entity = default(TEntity), Descriptions = Enumerable.Empty<object>()}.GetType();
// (entityManagerBaseEntity) => new { Entity = entityManagerBaseEntity, Descriptions = selectEntityDescriptions(entityManagerBaseEntity) }
// 1) "(entityManagerBaseEntity) =>"
var pe = Expression.Parameter(typeof(TEntity), "entityManagerBaseEntity");
// 2) "selectEntityDescriptions(entityManagerBaseEntity)"
var exprFunc = Expression.Invoke(selectEntityDescriptions, pe);
// get constructor for anonymous type
var constructorInfo = anonType.GetConstructor(new[] { typeof(TEntity), typeof(IEnumerable<object>) });
// 3) "new AnonType(entityManagerBaseEntity, exprFunc(entityManagerBaseEntity))"
var constructAnonType = Expression.New(constructorInfo, pe, exprFunc);
// 4) combine all to a lambda
// {entity => new <>f__AnonymousType0`2(entity, Invoke(entity => entity.Descriptions.Where(desc => desc.LanguageCode.Equals(DataLanguageContext.Current.DataLanguageCode)), entity))}
var cooleExpression = Expression.Lambda<Func<TEntity, dynamic>>(constructAnonType, pe);
//var bla = cooleExpression.Compile();
//var list = queryObjectSet.AsQueryable().Provider.CreateQuery<dynamic>(cooleExpression).ToList();
var list = queryObjectSet.Select(cooleExpression).ToList(); //perform query
var resultList = list
.Select(entity => entity.Entity as TEntity);
return resultList;
}
}
（注意：CreateObjectContext和GetObjectSet是完美的工作方法）
应该这样称呼：
_nutrientManager.FindAllForSpecificLanguage(true, (entity) => entity.Descriptions.Where(desc => desc.LanguageCode.Equals(DataLanguageContext.Current.DataLanguageCode)))
生成的表达式是在注释中键入的。我想这看起来不错，但连接从未执行过。如果我调试，我会得到以下堆栈：
系统。NotSupportedException：在LINQ to Entities中只支持无参数构造函数和初始化器。在系统中。数据实体果心对象。ELinq。ExpressionConverter。NewTranslator。TypedTranslate（ExpressionConverter父级，NewExpression linq）在系统中。数据实体果心对象。ELinq。ExpressionConverter。TypedTranslator`1.Translate（ExpressionConverter父级，Expression linq）
所以。。几件事：
- 不能调用L2E表达式中的函数
- 只能使用不带参数的构造函数
- 您可以在表达式中自己构建整个where子句
整个解决方案可以在这里找到：https://github.com/YoeriVD/entity-framework-filter-on-include/blob/master/ExpressionTrees/Program.cs
重要的部分是：
private static void Main(string[] args)
{
FilterOnInclude<Car, Wheel>(car => car.Wheels, wheel => wheel.SizeInInches == 14)
.ForEach(car => Console.WriteLine($"car : {car.Name} wheels: {car.Wheels.Count}"));
}
private static IEnumerable<TEntity> FilterOnInclude<TEntity, TChildEntity>(
Expression<Func<TEntity, IEnumerable<TChildEntity>>> propertyExpression,
Expression<Func<TChildEntity, bool>> predicateExpression)
where TEntity : class
{
using (var context = new CarContext())
{
context.Configuration.LazyLoadingEnabled = false;
var selector = CreateSelector(propertyExpression, predicateExpression);
return
context.Set<TEntity>().Select(
selector
).ToList().Select(e => e.Entity).ToArray();
}
}
private static Expression<Func<TEntity, EntityWithFilteredChildren<TEntity, TChildEntity>>> CreateSelector
<TEntity, TChildEntity>(
Expression<Func<TEntity, IEnumerable<TChildEntity>>> propertyExpression,
Expression<Func<TChildEntity, bool>> predicateExpression)
{
var selectType = typeof (EntityWithFilteredChildren<TEntity, TChildEntity>);
//bind entity
var entityValueParam = Expression.Parameter(typeof (TEntity), "entityValue");
var entityProp = selectType.GetProperty("Entity");
var entityValueAssignment = Expression.Bind(
entityProp, entityValueParam);
//bind collection
var childrenProp = selectType.GetProperty("Children");
var descriptionsMemberExpression = (propertyExpression.Body as MemberExpression);
var descriptionsPropertyInfo = (PropertyInfo) descriptionsMemberExpression.Member;
var descriptionsProperty = Expression.Property(entityValueParam, descriptionsPropertyInfo);
//perform where call
var whereCall = Expression.Call(typeof (Enumerable), "Where", new[] {typeof (TChildEntity)}, descriptionsProperty,
predicateExpression);
var descriptionValueAssignment = Expression.Bind(
childrenProp, whereCall);
var ctor = Expression.New(selectType);
var memberInit = Expression.MemberInit(ctor, entityValueAssignment, descriptionValueAssignment);
var selector = Expression.Lambda<Func<TEntity, EntityWithFilteredChildren<TEntity, TChildEntity>>>(memberInit,
entityValueParam);
return selector;
}
public class EntityWithFilteredChildren<T, TChild>
{
public T Entity { get; set; }
public IEnumerable<TChild> Children { get; set; }
}
显然，我不知道您的项目的更大结构，但您能否通过用TEntity替换Entities.Nutrient来使您的第一个示例更通用？这就是我在想的事情：
public IEnumerable<TEntity> FindAllForSpecificLanguage<TEntity>(
Func<DbContext, IEnumerable<TEntity>> selectEntities,
Func<TEntity, IEnumerable<object>> selectEntityDescriptions)
{
using (var context = CreateObjectContext())
{
context.ContextOptions.LazyLoadingEnabled = false;
var list = selectEntities(context)
.Select(nut => new
{
Entity = nut,
Descriptions = selectEntityDescriptions
}).ToList(); //perform query
var resultList = list
.Select(entity => entity.Entity);
return resultList;
}
}