包含在（半）通用存储库中

Question

我正在尝试弄清楚如何使用新的 EF Code First 内容，但在弄清楚如何将 Include 功能调整到半通用存储库类中时遇到了困难。 （我说半通用，因为类不是通用的，只是方法。所以我有一个存储库，本质上包装了一个聚合，并且您可以与属于该聚合一部分的所有实体交互，而不仅仅是单个实体。 ）

我的情况是，我有一个实体，它有一个总是需要加载的子项，然后是仅可选加载的其他子项，我想在我的存储库方法中包含一个简单的 bool 参数。就像这样：

public S GetByID<S>(int entityID, bool loadChildren = false) where S : class
{
  DbSet<S> set = _context.Set<S>();

  if (loadChildren)
    set = FullInclude<S>(set);
  else
    set = DefaultInclude<S>(set);

  return set.Find(entityID);
}

protected virtual DbSet<S> DefaultInclude<S>(DbSet<S> set) where S : class
{
  // base implementation just returns the set
  // derived versions would attach Includes to the set before returning it
  return set;
}

protected virtual DbSet<S> FullInclude<S>(DbSet<S> set) where S : class
{
  // base implementation just returns the set
  // derived versions would attach Includes to the set before returning it
  return set;
}

这是我的基础存储库，我希望能够重写派生类中的那些 XyzInclude 方法。但我需要用非通用实现来覆盖它们，这显然在语言级别上不起作用。

使用 Linq2Sql 这非常简单，因为我只需配置一个 DataLoadOptions 对象并将其附加到上下文即可。由于 Include API 脱离了 DbSet，我对如何最好地做到这一点感到困惑。我正在寻找有关策略模式或类似模式的简单实现的建议。

编辑：我想我的问题的本质实际上是关于用非泛型派生版本覆盖泛型方法。我正在寻找一种模式或技术可以让我做到这一点。扩展方法是我正在关注的一件事，但如果有人有的话，我更喜欢更“纯粹”的解决方案。

Answer 1

除非您使该类完全通用，否则不可能：

public class BaseRepo<S>
{
    protected virtual DbSet<S> DefaultInclude(DbSet<S> set) {return set;}
} 

public class ProductRepo : BaseRepo<Product>
{
    protected override DbSet<Product> DefaultInclude(DbSet<Product> set)
    {
       return set.Include("...");
    }
}

Answer 2

只是想我会用我最终得到的解决方案重新审视这个问题。我的存储库并不完全通用，但所有方法都是通用的，因此我需要一种方法来存储任何实体类型的包含内容，并能够在为该类型调用方法时将它们取出。

我借用了拉迪斯拉夫的答案这里，我可以重新审视这个设计，让派生存储库上定义的每个单独的方法都定义自己的包含，因为要包含的内容和不包含的内容有足够多的不同组合，因此在几个地方重复定义相同包含的一小部分代码可能是值得的。但无论如何，这是当前的设计并且它有效......

基础存储库：

public abstract class Repository : IQueryableRepository, IWritableRepository
{
  private readonly DbContext _context;
  private readonly Dictionary<Type, LambdaExpression[]> _includes = new Dictionary<Type, LambdaExpression[]>();

  protected Repository(DbContextBase context)
  {
    _context = context;
    RegisterIncludes(_includes);
  }

  protected abstract void RegisterIncludes(Dictionary<Type, LambdaExpression[]> includes);

  protected S GetSingle<S>(Expression<Func<S, bool>> query, bool getChildren = false) where S : class
  {
    IQueryable<S> entities = _context.Set<S>().AsNoTracking();

    if (query != null)
      entities = entities.Where(query);

    entities = ApplyIncludesToQuery<S>(entities, getChildren);

    return entities.FirstOrDefault();
  }

  private IQueryable<S> ApplyIncludesToQuery<S>(IQueryable<S> entities, bool getChildren) where S : class
  {
    Expression<Func<S, object>>[] includes = null;

    if (getChildren && _includes.ContainsKey(typeof(S)))
      includes = (Expression<Func<S, object>>[])_includes[typeof(S)];

    if (includes != null)
      entities = includes.Aggregate(entities, (current, include) => current.Include(include));

    return entities;
  }
}

派生存储库只需要在一处定义它们的包含，然后当您调用查询方法时，您只需指定是否希望包含子项（请参阅上面的getChildren）。

public class DerivedRepository : Repository
{
  public DerivedRepository(DbContext context)
    : base(context) { }

  protected override void RegisterIncludes(Dictionary<Type, LambdaExpression[]> includes)
  {
    includes.Add(typeof(ParentType), new Expression<Func<ParentType, object>>[] { 
      p => p.SomeChildReference.SomeGrandchild,
      p => p.SomeOtherChildReference
    });
  }
}