C# 我想以一种很难理解的简单方式使用接口继承

我有一个实体框架数据库上下文，它通过依赖项注入注入到系统的三个部分中，这三个部分都通过三个单独的接口具有不同的需求

我们需要以不同的方式将信息传递到Save方法，现在我们为每种类型提供了一个接口，就像这样

public interface IIntegrationDbContext
{
    IDbSet<DataOne> DataOnes { get; set; }
    IDbSet<DataTwo> DataTwos { get; set; }
    Task<int> SaveChangesAsync(Customer customer);
}

public interface IProfessionalDbContext
{
    IDbSet<DataOne> DataOnes { get; set; }
    IDbSet<DataTwo> DataTwos { get; set; }
    Task<int> SaveChangesAsync(ProfessionalUser user);
}

public interface IPublicDbContext
{
    IDbSet<DataOne> DataOnes { get; set; }
    IDbSet<DataTwo> DataTwos { get; set; }
    Task<int> SaveChangesAsync(PublicDomain domain);
}

提示抽象类中的情况

但我没有找到比使用三个独立接口的解决方案更好的解决方法

我错过了解决这个问题的简单而好的方法吗？

不仅仅是：

edit:由于您展示的示例中唯一的实际差异是

savechangesync

的参数类型，我的第一反应是简单地将该参数设置为泛型：

public interface IIntegrationDbContext<TUser>
{
    IDbSet<DataOne> DataOnes { get; set; }
    IDbSet<DataTwo> DataTwos { get; set; }
    Task<int> SaveChangesAsync(TUser user);
}

公共接口IIintegrationDBContext
{
IDbSet数据元{get；set；}
IDbSet DataTwos{get；set；}
任务保存更改同步（TUser用户）；
}

这不仅仅是：

edit:由于您展示的示例中唯一的实际差异是

savechangesync

的参数类型，我的第一反应是简单地将该参数设置为泛型：

public interface IIntegrationDbContext<TUser>
{
    IDbSet<DataOne> DataOnes { get; set; }
    IDbSet<DataTwo> DataTwos { get; set; }
    Task<int> SaveChangesAsync(TUser user);
}

公共接口IIintegrationDBContext
{
IDbSet数据元{get；set；}
IDbSet DataTwos{get；set；}
任务保存更改同步（TUser用户）；
}

我假设：

• 您希望共享

  DbSet

  属性，但希望覆盖流程的

  保存部分

• 您需要用于单元测试和/或依赖项注入的显式

  DbContext

  类接口

这是我认为设计的第一次迭代（很抱歉代码太多）：

//公共接口
公共接口icommondbset
{
IDbSet数据元{get；}
IDbSet DataTwos{get；}
}
公共接口工作单元
{
任务保存更改同步（TUser用户）；
}
//特定接口聚合
公共接口IIintegrationDBContext:ICommonDbSets，IUnitOfWork
{
}
公共接口IProfessionalDbContext:ICommonDbSets，IUnitOfWork
{
}
公共接口IPublicDbContext:ICommonDbSets，IUnitOfWork
{
}
//执行契约的基类
公共抽象类AbstractDbContext:ICommonDbSets，IUnitOfWork
{
私有只读dbcontextu DbContext；
受保护的AbstractDbContext（DbContext DbContext）
{
_dbContext=dbContext；
}
公共IDbSet数据元
{
获取{return _dbContext.Set（）；}
}
公共IDbSet数据集
{
获取{return _dbContext.Set（）；}
}
公共抽象任务saveChangesSync（TUser用户）；
}
//具体实施
公共密封类IntegrationDbContext:AbstractDbContext，IIintegrationDBContext
{
公共集成DbContext（DbContext DbContext）：基（DbContext）
{
}
公共覆盖任务SaveChangesSync（客户用户）
{
抛出新的NotImplementedException（）；
}
}
公共密封类ProfessionalDbContext:AbstractDbContext，IProfessionalDbContext
{
public ProfessionalDbContext（DbContext DbContext）：基本（DbContext）
{
}
公共覆盖任务SaveChangesSync（专业用户）
{
抛出新的NotImplementedException（）；
}
}
公共密封类PublicDbContext:AbstractDbContext，IPPublicDbContext
{
PublicPublicDbContext（DbContext）：基本（DbContext）
{
}
公共覆盖任务SaveChangesSync（公共域用户）
{
抛出新的NotImplementedException（）；
}
}

EDIT:请注意，这将迫使您在抽象基类中实现添加到

ICommonDbSets

的任何内容，并且还将迫使您在具体的DbContext实现中覆盖

savechangesync

---

EDIT2:请注意，您不需要在具体类（

IntegrationDbContext

，

professiondbcontext

，

publicdcontext

）中实现

icommondbset

），因为它们已经在抽象基类中实现了

• 您希望共享

  DbSet

  属性，但希望覆盖流程的

  保存部分

• 您需要用于单元测试和/或依赖项注入的显式

  DbContext

  类接口

这是我认为设计的第一次迭代（很抱歉代码太多）：

//公共接口
公共接口icommondbset
{
IDbSet数据元{get；}
IDbSet DataTwos{get；}
}
公共接口工作单元
{
任务保存更改同步（TUser用户）；
}
//特定接口聚合
公共接口IIintegrationDBContext:ICommonDbSets，IUnitOfWork
{
}
公共接口IProfessionalDbContext:ICommonDbSets，IUnitOfWork
{
}
公共接口IPublicDbContext:ICommonDbSets，IUnitOfWork
{
}
//执行契约的基类
公共抽象类AbstractDbContext:ICommonDbSets，IUnitOfWork
{
私有只读dbcontextu DbContext；
受保护的AbstractDbContext（DbContext DbContext）
{
_dbContext=dbContext；
}
公共IDbSet数据元
{
获取{return _dbContext.Set（）；}
}
公共IDbSet数据集
{
获取{return _dbContext.Set（）；}
}
公共抽象任务saveChangesSync（TUser用户）；
}
//具体实施
公共密封类IntegrationDbContext:AbstractDbContext，IIintegrationDBContext
{
公共集成DbContext（DbContext DbContext）：基（DbContext）
{
}
公共覆盖任务SaveChangesSync（客户用户）
{
抛出新的NotImplementedException（）；
}
}
公共密封类ProfessionalDbContext:AbstractDbContext，IProfessionalDbContext
{
public ProfessionalDbContext（DbContext DbContext）：基本（DbContext）
{
}
公共覆盖任务saveChangesSync（专业）
public interface IIntegrationDbContext<TUser>
{
    IDbSet<DataOne> DataOnes { get; set; }
    IDbSet<DataTwo> DataTwos { get; set; }
    Task<int> SaveChangesAsync(TUser user);
}

// Common Interfaces

public interface ICommonDbSets
{
    IDbSet<DataOne> DataOnes { get; }
    IDbSet<DataTwo> DataTwos { get; }
}

public interface IUnitOfWork<TUser>
{
    Task<int> SaveChangesAsync(TUser user);
}


// Specific interface aggregation

public interface IIntegrationDbContext : ICommonDbSets, IUnitOfWork<Customer>
{
}

public interface IProfessionalDbContext : ICommonDbSets, IUnitOfWork<ProfessionalUser>
{
}

public interface IPublicDbContext : ICommonDbSets, IUnitOfWork<PublicDomain>
{
}

// Base class to enforce contract

public abstract class AbstractDbContext<TUser> : ICommonDbSets, IUnitOfWork<TUser>
{
    private readonly DbContext _dbContext;

    protected AbstractDbContext(DbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public IDbSet<DataOne> DataOnes
    {
        get { return _dbContext.Set<DataOne>(); }

    }

    public IDbSet<DataTwo> DataTwos
    {
        get { return _dbContext.Set<DataTwo>(); }
    }

    public abstract Task<int> SaveChangesAsync(TUser user);
}

// Specific implementations

public sealed class IntegrationDbContext : AbstractDbContext<Customer>, IIntegrationDbContext
{
    public IntegrationDbContext(DbContext dbContext) : base(dbContext)
    {
    }

    public override Task<int> SaveChangesAsync(Customer user)
    {
        throw new NotImplementedException();
    }
}

public sealed class ProfessionalDbContext : AbstractDbContext<ProfessionalUser>, IProfessionalDbContext
{
    public ProfessionalDbContext(DbContext dbContext) : base(dbContext)
    {
    }

    public override Task<int> SaveChangesAsync(ProfessionalUser user)
    {
        throw new NotImplementedException();
    }
}

public sealed class PublicDbContext : AbstractDbContext<PublicDomain>, IPublicDbContext
{
    public PublicDbContext(DbContext dbContext) : base(dbContext)
    {
    }

    public override Task<int> SaveChangesAsync(PublicDomain user)
    {
        throw new NotImplementedException();
    }
}