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

Stack Overflow用户

提问于 2016-05-26 06:06:23

回答 2查看 6.9K关注 0票数 15

我的应用程序使用实体框架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之前，我相信以下内容也可以检索与每个订单相关联的LineItems：

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

但是，在EF7中似乎不支持这一点。相反，有一个新的ThenInclude方法检索嵌套实体的其他级别：

https://github.com/aspnet/EntityFramework/wiki/Design-Meeting-Notes:-January-8,-2015

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

eager-loading

entity-framework-core

entity-framework

repository-pattern

云直播特惠9.9元起

针对高并发播放、高并发推流、超低延迟等不同直播场景，提供极速、稳定、专业的一站式云端直播处理服务

回答 2

Stack Overflow用户

回答已采纳

发布于 2017-05-11 17:50:41

这是个老生常谈的问题，但由于没有一个被接受的答案，我想我应该把我的解决方案发出来。

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

我目前的实现只支持IQueryable方法(即。FirstOrDefault，Where，基本上是标准的lambda函数)，但我确信您可以使用它传递到特定的存储库方法。

我从EF的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。在其中，我在Include上调用EF、ThenInclude和DbSet方法：

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方法，然后返回一个新的IncludableJoin对象来支持方法链接。

就是这样。它的用法如下：

IAccount account = _accountRepository.Join(x=>x.Subscription).Join(x=>x.Addresses).ThenJoin(x=>x.Address).FirstOrDefault(x => x.UserId == userId);

上面将加载基本的Account实体，它是一对一的子Subscription，它是一对多的子列表Addresses，它是子Address。整个过程中的每个lambda函数都是强类型的，并且得到intellisense的支持，以显示每个实体上可用的属性。

票数 14

Stack Overflow用户

发布于 2016-05-26 07:47:07

您可以将其更改为以下内容：

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