如何使用匿名投影重構此方法以使其更通用？

Question

我所擁有的是以下方法。 我使用匿名投影來過濾EF包含的內容。 我從此博客文章中了解了這種方法： 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種語言，此刻我們有很多數據庫開銷...）。 我試圖以一種通用的方式來構建它，但是我對表達式樹缺乏經驗。 我以為我完全重新創建了該函數，但是由於它無法正常工作，我錯過了一些東西。 這是我到目前為止的內容：

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)))

在注釋中鍵入要構建的表達式。 我猜看起來不錯，但是連接從未執行。 如果我調試，則會得到以下堆棧跟蹤：

System.NotSupportedException：在LINQ to Entities中僅支持無參數構造函數和初始化程序。 在System.Data.Entity.Core.Objects.ELinq.ExpressionConverter.TypedTranslator`1.Translate（ExpressionConverter父類，Expression）處LINQ）

Answer 1

所以..幾件事：

1. 您不能在e L2E表達式中調用函數
2. 您只能使用沒有參數的構造函數
3. 您可以自己在表達式中構建整個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; }
    }

Answer 2

顯然，我不知道您的項目的更大結構，但是您可以通過用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;
    }
}