Question

我的应用程序使用Entity Framework 7和存储库模式。

存储库上的GetById方法支持急切加载子实体：

    public virtual TEntity GetById(int id, params Expression<Func<TEntity, object>>[] paths)
    {
        var result = this.Set.Include(paths.First());
        foreach (var path in paths.Skip(1))
        {
            result = result.Include(path);
        }
        return result.FirstOrDefault(e => e.Id == id);
    }

使用如下检索产品（其ID为2）以及订单和与该产品相关的部件：

productRepository.GetById(2, p => p.Orders, p => p.Parts);

我想增强此方法以支持嵌套深度超过一个级别的实体的预先加载。例如，假设Order有自己的LineItem集合。

在EF7之前，我相信以下内容也可以检索与每个订单相关联的LineItem：

productRepository.GetById(2, p => p.Orders.Select(o => o.LineItems), p => p.Parts);

然而，EF7似乎不支持此功能。相反，有一个新的ThenInclude方法可以检索其他级别的嵌套实体：

Haskell Programming from First Principles

我不确定如何更新我的存储库以支持使用ThenInclude检索多级预先加载的实体。

Answer 1

这是一个老问题，但由于它没有一个公认的答案，我以为我会发布我的解决方案。

我正在使用EF Core，并希望这样做，从我的存储库类外部访问急切加载，这样我就可以指定每次调用存储库方法时加载的导航属性。由于我有大量的表和数据，所以我不想要一组标准的急切加载实体，因为我的一些查询只需要父实体，而有些需要整个树。

我当前的实现仅支持IQueryable方法（即。FirstOrDefault，Where，基本上是标准的lambda函数）但我相信你可以使用它来传递给你的特定存储库方法。

我开始使用EF Core EntityFrameworkQueryableExtensions.cs的源代码，这是定义Include和ThenInclude扩展方法的地方。不幸的是，EF使用内部类IncludableQueryable来保存以前属性的树，以允许强类型以后包含。但是，对此的实现只不过是IQueryable，前一个实体具有额外的泛型类型。

我创建了自己的版本，我调用了IncludableJoin，它将IIncludableQueryable作为构造函数参数并将其存储在私有字段中以供以后访问：

public interface IIncludableJoin<out TEntity, out TProperty> : IQueryable<TEntity>
{
}

public class IncludableJoin<TEntity, TPreviousProperty> : IIncludableJoin<TEntity, TPreviousProperty>
{
    private readonly IIncludableQueryable<TEntity, TPreviousProperty> _query;

    public IncludableJoin(IIncludableQueryable<TEntity, TPreviousProperty> query)
    {
        _query = query;
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public IEnumerator<TEntity> GetEnumerator()
    {
        return _query.GetEnumerator();
    }

    public Expression Expression => _query.Expression;
    public Type ElementType => _query.ElementType;
    public IQueryProvider Provider => _query.Provider;

    internal IIncludableQueryable<TEntity, TPreviousProperty> GetQuery()
    {
        return _query;
    }
}

请注意内部GetQuery方法。这在以后很重要。

接下来，在我的通用IRepository界面中，我定义了预先加载的起点：

public interface IRepository<TEntity> where TEntity : class
{
    IIncludableJoin<TEntity, TProperty> Join<TProperty>(Expression<Func<TEntity, TProperty>> navigationProperty);
    ...
}

TEntity泛型类型是我的EF实体的接口。我的通用存储库中Join方法的实现如下：

public abstract class SecureRepository<TInterface, TEntity> : IRepository<TInterface>
    where TEntity : class, new()
    where TInterface : class
{
    protected DbSet<TEntity> DbSet;
    protected SecureRepository(DataContext dataContext)
    {
        DbSet = dataContext.Set<TEntity>();
    }

    public virtual IIncludableJoin<TInterface, TProperty> Join<TProperty>(Expression<Func<TInterface, TProperty>> navigationProperty)
    {
        return ((IQueryable<TInterface>)DbSet).Join(navigationProperty);
    }
    ...
}

现在，对于实际允许多个Include和ThenInclude的部分。我有几个接受和返回的扩展方法，IIncludableJoin允许方法链接。我在其中调用DbSet上的EF Include和ThenInclude方法：

public static class RepositoryExtensions
{
    public static IIncludableJoin<TEntity, TProperty> Join<TEntity, TProperty>(
        this IQueryable<TEntity> query,
        Expression<Func<TEntity, TProperty>> propToExpand)
        where TEntity : class
    {
        return new IncludableJoin<TEntity, TProperty>(query.Include(propToExpand));
    }

    public static IIncludableJoin<TEntity, TProperty> ThenJoin<TEntity, TPreviousProperty, TProperty>(
         this IIncludableJoin<TEntity, TPreviousProperty> query,
         Expression<Func<TPreviousProperty, TProperty>> propToExpand)
        where TEntity : class
    {
        IIncludableQueryable<TEntity, TPreviousProperty> queryable = ((IncludableJoin<TEntity, TPreviousProperty>)query).GetQuery();
        return new IncludableJoin<TEntity, TProperty>(queryable.ThenInclude(propToExpand));
    }

    public static IIncludableJoin<TEntity, TProperty> ThenJoin<TEntity, TPreviousProperty, TProperty>(
        this IIncludableJoin<TEntity, IEnumerable<TPreviousProperty>> query,
        Expression<Func<TPreviousProperty, TProperty>> propToExpand)
        where TEntity : class
    {
        var queryable = ((IncludableJoin<TEntity, IEnumerable<TPreviousProperty>>)query).GetQuery();
        var include = queryable.ThenInclude(propToExpand);
        return new IncludableJoin<TEntity, TProperty>(include);
    }
}

在这些方法中，我使用上述IIncludableQueryable方法获取内部GetQuery属性，调用相关的Include或ThenInclude方法，然后返回新的{{1 object支持方法链接。

就是这样。使用方法如下：

IncludableJoin

上面会加载基础IAccount account = _accountRepository.Join(x=>x.Subscription).Join(x=>x.Addresses).ThenJoin(x=>x.Address).FirstOrDefault(x => x.UserId == userId);实体，它是一对一的孩子Account，它是一对多子列表Subscription，它是孩子Addresses 。沿途的每个lambda函数都是强类型的，并由intellisense支持，以显示每个实体上可用的属性。

Answer 2

您可以将其更改为：

public virtual TEntity GetById<TEntity>(int id, Func<IQueryable<TEntity>, IQueryable<TEntity>> func) 
{
    DbSet<TEntity> result = this.Set<TEntity>();

    IQueryable<TEntity> resultWithEagerLoading = func(result);

    return resultWithEagerLoading.FirstOrDefault(e => e.Id == id);
}

你可以像这样使用它：

productRepository.GetById(2, x => x.Include(p => p.Orders)
                                   .ThenInclude(o => o.LineItems)
                                   .Include(p => p.Parts))

使用存储库模式使用ThenIclude来加载实体

2 个答案: