具有实体框架的C#数据库抽象类

我想创建一个公共数据库抽象，以便公开相同的接口，而不必担心数据库管理的

DbContext

的类型

这里有一个例子可以很好地解释这个概念：

public interface IDatabase<T> where T : DbContext {
    void Add<T>(T entity);
    void Remove<T>(T entity);
    void SaveChanges();
}

公共接口IDatabase，其中T:DbContext{
无效添加（T实体）；
无效删除（T实体）；
void SaveChanges（）；
}

实施可以是：

public MyDatabase<T> : IDatabase<T> where T : MyContext {
    public T Context { get; private set; }

    //singleton contructor ...

    public void Add<TC>(TC entity) {
        Context.Set<TC>().Add(entity);
    }

    public void Remove<TC>(TC entity) {
        Context.Set<TC>().Add(entity);
    }

    public void SaveChanges {
        Context.SaveChanges();
    }
}

公共MyDatabase:IDatabase其中T:MyContext{
公共T上下文{get；私有集；}
//单态构造函数。。。
公共无效添加（TC实体）{
Context.Set（）.Add（实体）；
}
公共无效删除（TC实体）{
Context.Set（）.Add（实体）；
}
公开作废保存更改{
SaveChanges（）；
}
}

此设计的目标是不同的：公开相同的接口，以便从数据库中解耦逻辑，快速更改数据库（上下文），创建一次上下文，并在整个应用程序生命周期中重用（需要锁定机制）

问题是接口隐藏了上下文中所有类型的集合

Context.Set<TC>().Add(entity);    //this line don't compile

Context.Set（）.Add（实体）//这行代码不可编译

---

我不确定这种设计是否是最佳实践。如何实现提供这些功能的设计？

为什么不使用标准模式，例如存储库模式，也可以将其与UnitOfWork结合使用。 你把事情弄复杂了，检查一下

 public interface IMyClassRepository : IDisposable
  {
    IQueryable<MyClass> All { get; }
    IQueryable<MyClass> AllIncluding(params Expression<Func<MyClass, object>>[] includeProperties);
    MyClass Find(int id);
    void InsertOrUpdate(MyClass myClass);
    void Delete(int id);
    void Save();
  }

  public class MyClassRepository : IMyClassRepository
  {
    DBContext context = new DBContext();
    public IQueryable<MyClass> All
    {
      get { return context.Employees; }
    }
    public IQueryable<MyClass> AllIncluding(params Expression<Func<MyClass, object>>[] includeProperties)
    {
      IQueryable<MyClass> query = context.MyClasses;
      foreach (var includeProperty in includeProperties)
      {
        query = query.Include(includeProperty);
      }
      return query;
    }
    public MyClass Find(int id)
    {
      return context.MyClasses.Find(id);
    }
    public void InsertOrUpdate(MyClass myClass)
    {
      if (myClass.Id == default(int))
      {
        // New entity
        context.MyClasses.Add(myClass);
      }
      else
      {
        // Existing entity
        context.Entry(myClass).State = EntityState.Modified;
      }
    }
    public void Delete(int id)
    {
      var employee = context.Employees.Find(id);
      context.Employees.Remove(employee);
    }
    public void Save()
    {
      context.SaveChanges();
    }
    public void Dispose()
    {
      context.Dispose();
    }
  }

  public class MyClass
  {
  }

公共接口IMyClassRepository:IDisposable
{
IQueryable所有{get；}
可计量的所有包括（参数表达式[]包括属性）；
MyClass查找（int-id）；
无效插入更新（MyClass MyClass）；
无效删除（int-id）；
作废保存（）；
}
公共类MyClassRepository:IMyClassRepository
{
DBContext=新的DBContext（）；
公共图书馆
{
获取{return context.Employees；}
}
公共可查询全部包含（参数表达式[]包含属性）
{
IQueryable query=context.MyClasses；
foreach（includeProperty中的var includeProperty）
{
query=query.Include（includeProperty）；
}
返回查询；
}
公共MyClass查找（int id）
{
返回context.MyClasses.Find（id）；
}
公共void InsertOrUpdate（MyClass MyClass）
{
if（myClass.Id==默认值（int））
{
//新实体
context.MyClasses.Add（myClass）；
}
其他的
{
//现有实体
context.Entry（myClass）.State=EntityState.Modified；
}
}
公共无效删除（int-id）
{
var employee=context.Employees.Find（id）；
context.Employees.Remove（雇员）；
}
公共作废保存（）
{
SaveChanges（）；
}
公共空间处置（）
{
context.Dispose（）；
}
}
公共类MyClass
{
}

这是一个很好的解决方案。您可以看看我对类似问题的回答：它被称为存储库模式，存储库模式通常与工作单元模式一起使用。您可以查看以下示例：