如何从我的接口中删除DbSet

如果您接受显式实现，并且不介意在实现中增加几行代码，那么您可以很容易地从接口中删除DbSet：

public interface IMyDbContext
{
    ICollection<Customer> Customers { get; }
}
public class MyDbContext : IMyContext
{
    ICollection<Customer> IMyContext.Customers { get { return (ICollection<Customer>)Customers; } }
    public DbSet<Customer> Customers { get; set; }
}

编辑：我发布了这个答案，然后重读了这个问题，然后删除了它，现在又回来了。这将为您提供从集合中添加/删除所需的内容。如果你想要一个额外的IQueryable，你可以用另一个接口和显式实现来分层。然而，这变得很丑陋。

你真正想要的是使用一个IDbSet并创建一个类，比如这个DbSet的替换

public class MemoryDbSet<TEntity> : DbSet<TEntity>, IQueryable,
    IEnumerable<TEntity>, IDbAsyncEnumerable<TEntity>
    where TEntity : class
{
    private readonly Func<TEntity, object[], bool> _findSelector;
    private readonly ObservableCollection<TEntity> _data;
    private readonly IQueryable _query;
    public MemoryDbSet(Func<TEntity, object[], bool> findSelector)
    {
        _findSelector = findSelector;
        _data = new ObservableCollection<TEntity>();
        _query = _data.AsQueryable();
    }
    public override TEntity Find(params object[] keyValues)
    {
        return _data.SingleOrDefault(item => _findSelector(item, keyValues));
    }
    public override TEntity Add(TEntity item)
    {
        _data.Add(item);
        return item;
    }
    public override TEntity Remove(TEntity item)
    {
        _data.Remove(item);
        return item;
    }
    public override TEntity Attach(TEntity item)
    {
        _data.Add(item);
        return item;
    }
    public override TEntity Create()
    {
        return Activator.CreateInstance<TEntity>();
    }
    public override TDerivedEntity Create<TDerivedEntity>()
    {
        return Activator.CreateInstance<TDerivedEntity>();
    }
    public override ObservableCollection<TEntity> Local
    {
        get { return _data; }
    }
    Type IQueryable.ElementType
    {
        get { return _query.ElementType; }
    }
    Expression IQueryable.Expression
    {
        get { return _query.Expression; }
    }
    IQueryProvider IQueryable.Provider
    {
        get
        {
            return new MemoryDbAsyncQueryProvider<TEntity>(_query.Provider);
        }
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return _data.GetEnumerator();
    }
    IEnumerator<TEntity> IEnumerable<TEntity>.GetEnumerator()
    {
        return _data.GetEnumerator();
    }
    IDbAsyncEnumerator<TEntity> IDbAsyncEnumerable<TEntity>.
        GetAsyncEnumerator()
    {
        return new MemoryDbAsyncEnumerator<TEntity>(_data.GetEnumerator());
    }
}

你不应该做你正在做的事情！

public class DbContextFactory : IDbContextFactory<BlogDb>
{
    public BlogDb Create() 
    {
        return new BlogDb();
    }
}

然后将其注入您的控制器：

public class MyController : Controller
{
    private readonly IDbContextFactory<BlogDb> blogContextFactory;
    public MyController(IDbContextFactory<BlogDb> blogContextFactory)
    {
        this.blogContextFactory = blogContextFactory;
    }
}

然后在你的方法中，你应该正确地处理上下文：

public ActionResult SaveRecord(FormCollection formStuff)
{
    if (ModelState.IsValid)
    {
         try
         {
             using ( var context = blogContextFactory.Create())
             {
                 // do you stuff here!
             }
         }
    }
}

原因是你不想打开数据库连接！

既然您正确地使用了context，那么您就可以为自己创建一个公开该方法的服务，在该服务中您可以隐藏上下文实现。

public class MyService : IMyService
{
    private readonly IDbContextFactory<BlogDb> blogContextFactory;
    public MyService(IDbContextFactory<BlogDb> blogContextFactory)
    {
        this.blogContextFactory = blogContextFactory;
    }
    public void CreateBlog(FormCollection formStuff) {};
    public void UpdateBlog() {};
    public IQueryable<Blog> Retrieve(Func<Blog, bool> predicate)
    {
        return this.context.Blogs.Where(predicate);
    }
}

因此，IMyService是您的控制器将与之交互的对象，因此它被称为接口或契约。因此，这就是您想要公开操纵博客上下文的方法的地方：

public interface IMyService
{
     void CreateBlog(Blog blog); // you can have what ever passed through to the create, a viewModel, a DTO model or the Domain model. Personally I choose the DTO model.
     void UpdateBlog(Blog blog);
     void DeleteBlog(Guid id);
     IQueryable<Blog> RetreiveBlogs(Func<Blog, bool> predicate); // the predicate allows you to do a quick query if you want to
}

所以在你的控制器中改为：

public class MyController : Controller
{
    private readonly IMyService blogService;
    public MyController(IMyService blogService)
    {
        this.blogService= blogService;
    }
    public ActionResult SaveRecord(FormCollection formStuff)
    {
        if (ModelState.IsValid)
        {
             try
             {
                 this.blogService.CreateBlog(formStuff);
             }
        }
     }
}