C# 服务及；存储库->；请帮助我不要重复代码

我正在C#中创建一个MVC Web应用程序，它从一个漂亮而简单的DbContext开始。然后我创建了存储库以便编写单元测试。。。然后我实现了依赖注入。。哦，不，现在我想在我的控制器和存储库之间创建一个服务层

除了我不知道如何在服务中从我的存储库调用通用函数之外，它几乎就在那里

var tenantRepository = new TenantRepository(myself, mydbProvider);
var tenantService = new TenantService(tenantRepository);
var tenants = tenantService.Find();

我是否必须重复服务中的所有通用存储库功能

这是通用存储库：

public interface IRepository<TEntity> : IDisposable where TEntity : class
{

    int Count { get; }

    IEnumerable<TEntity> Get(
      Expression<Func<TEntity, bool>> filter = null,
      Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
      string includeProperties = "");

    IQueryable<TEntity> All();

    TEntity GetByID(object id);
    void Insert(TEntity entity);
    void Delete(object id);
    void Delete(TEntity entityToDelete);
    void Update(TEntity entityToUpdate);
    void Save();

}

public abstract class Repository<CEntity, TEntity> : IRepository<TEntity> where TEntity : class 
                                                                    where CEntity : DbContext, new()
{
    private CEntity entities = new CEntity();
    protected CEntity context
    {
        get { return entities; }
        set { entities = value; }
    }

    public virtual int Count 
    {
        get { return entities.Set<TEntity>().Count(); }
    }

    public virtual IEnumerable<TEntity> Get(
        Expression<Func<TEntity, bool>> filter = null,
        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
        string includeProperties = "")
    {
        IQueryable<TEntity> query = entities.Set<TEntity>();

        if (filter != null)
        {
            query = query.Where(filter);
        }

        foreach (var includeProperty in includeProperties.Split
            (new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
        {
            query = query.Include(includeProperty);
        }

        if (orderBy != null)
        {
            return orderBy(query).ToList();
        }
        else
        {
            return query.ToList();
        }
    }

    public virtual IQueryable<TEntity> All()
    {
        return entities.Set<TEntity>().AsQueryable();
    }

    public virtual TEntity GetByID(object id)
    {
        return entities.Set<TEntity>().Find(id);
    }

    public virtual void Insert(TEntity entity)
    {
        entities.Set<TEntity>().Add(entity);
    }

    public virtual void Delete(object id)
    {
        TEntity entityToDelete = entities.Set<TEntity>().Find(id);
        Delete(entityToDelete);
    }

    public virtual void Delete(TEntity entityToDelete)
    {
        if (context.Entry(entityToDelete).State == EntityState.Detached)
        {
            entities.Set<TEntity>().Attach(entityToDelete);
        }
        entities.Set<TEntity>().Remove(entityToDelete);
    }

    public virtual void Update(TEntity entityToUpdate)
    {
        entities.Set<TEntity>().Attach(entityToUpdate);
        context.Entry(entityToUpdate).State = EntityState.Modified;
    }

    public virtual void Save()
    {
        entities.SaveChanges();
    }

    private bool disposed = false;

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                context.Dispose();
            }
        }
        this.disposed = true;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}

public class CampaignService : ICampaignService 
{
    private readonly IRepository<Campaign> _campaignRepository;

    public CampaignService(IRepository<Campaign> campaignRepository)
    {
        _campaignRepository = campaignRepository;
    }

    public Campaign GetLatestCampaign()
    {
        var query = _campaignRepository.Get(x => x.CreatedOn != null, q => q.OrderByDescending(s => s.CreatedOn));
        Campaign result = query.First();

        return result;
    }

}

public interface ICampaignService
{
    Campaign GetLatestCampaign();
}

公共接口IRepository:IDisposable其中tenty:class
{
整数计数{get；}
数不清的(
表达式筛选器=空，
Func orderBy=null，
字符串includeProperty=“”）；
IQueryable All（）；
TEntity GetByID（对象id）；
无效插入（TEntity实体）；
作废删除（对象id）；
无效删除（TEntity entityToDelete）；
无效更新（TEntity entityToUpdate）；
作废保存（）；
}

EF存储库：

public interface IRepository<TEntity> : IDisposable where TEntity : class
{

    int Count { get; }

    IEnumerable<TEntity> Get(
      Expression<Func<TEntity, bool>> filter = null,
      Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
      string includeProperties = "");

    IQueryable<TEntity> All();

    TEntity GetByID(object id);
    void Insert(TEntity entity);
    void Delete(object id);
    void Delete(TEntity entityToDelete);
    void Update(TEntity entityToUpdate);
    void Save();

}

public abstract class Repository<CEntity, TEntity> : IRepository<TEntity> where TEntity : class 
                                                                    where CEntity : DbContext, new()
{
    private CEntity entities = new CEntity();
    protected CEntity context
    {
        get { return entities; }
        set { entities = value; }
    }

    public virtual int Count 
    {
        get { return entities.Set<TEntity>().Count(); }
    }

    public virtual IEnumerable<TEntity> Get(
        Expression<Func<TEntity, bool>> filter = null,
        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
        string includeProperties = "")
    {
        IQueryable<TEntity> query = entities.Set<TEntity>();

        if (filter != null)
        {
            query = query.Where(filter);
        }

        foreach (var includeProperty in includeProperties.Split
            (new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
        {
            query = query.Include(includeProperty);
        }

        if (orderBy != null)
        {
            return orderBy(query).ToList();
        }
        else
        {
            return query.ToList();
        }
    }

    public virtual IQueryable<TEntity> All()
    {
        return entities.Set<TEntity>().AsQueryable();
    }

    public virtual TEntity GetByID(object id)
    {
        return entities.Set<TEntity>().Find(id);
    }

    public virtual void Insert(TEntity entity)
    {
        entities.Set<TEntity>().Add(entity);
    }

    public virtual void Delete(object id)
    {
        TEntity entityToDelete = entities.Set<TEntity>().Find(id);
        Delete(entityToDelete);
    }

    public virtual void Delete(TEntity entityToDelete)
    {
        if (context.Entry(entityToDelete).State == EntityState.Detached)
        {
            entities.Set<TEntity>().Attach(entityToDelete);
        }
        entities.Set<TEntity>().Remove(entityToDelete);
    }

    public virtual void Update(TEntity entityToUpdate)
    {
        entities.Set<TEntity>().Attach(entityToUpdate);
        context.Entry(entityToUpdate).State = EntityState.Modified;
    }

    public virtual void Save()
    {
        entities.SaveChanges();
    }

    private bool disposed = false;

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                context.Dispose();
            }
        }
        this.disposed = true;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}

public class CampaignService : ICampaignService 
{
    private readonly IRepository<Campaign> _campaignRepository;

    public CampaignService(IRepository<Campaign> campaignRepository)
    {
        _campaignRepository = campaignRepository;
    }

    public Campaign GetLatestCampaign()
    {
        var query = _campaignRepository.Get(x => x.CreatedOn != null, q => q.OrderByDescending(s => s.CreatedOn));
        Campaign result = query.First();

        return result;
    }

}

public interface ICampaignService
{
    Campaign GetLatestCampaign();
}

公共抽象类存储库：IRepository其中tenty:class
其中CEntity:DbContext，new（）
{
私有分位数实体=新分位数（）；
受保护的百分位上下文
{
获取{返回实体；}
设置{entities=value；}
}
公共虚拟整数计数
{
获取{return entities.Set（）.Count（）；}
}
公共虚拟IEnumerable Get(
表达式筛选器=空，
Func orderBy=null，
字符串includeProperties=“”）
{
IQueryable query=entities.Set（）；
if（过滤器！=null）
{
query=query.Where（过滤器）；
}
foreach（includeProperty.Split中的var includeProperty
（新字符[]{'，}，StringSplitOptions.RemoveEmptyEntries）
{
query=query.Include（includeProperty）；
}
if（orderBy！=null）
{
returnorderby（query.ToList（）；
}
其他的
{
返回query.ToList（）；
}
}
公共虚拟IQueryable All（）
{
返回实体.Set（）.AsQueryable（）；
}
公共虚拟实体GetByID（对象id）
{
返回entities.Set（）.Find（id）；
}
公共虚拟空白插入（TEntity实体）
{
entities.Set（）.Add（实体）；
}
公共虚拟无效删除（对象id）
{
TEntity entityToDelete=entities.Set（）.Find（id）；
删除（entityToDelete）；
}
公共虚拟无效删除（TEntity entityToDelete）
{
if（context.Entry（entityToDelete.State==EntityState.Detached）
{
entities.Set（）.Attach（entityToDelete）；
}
entities.Set（）.Remove（entityToDelete）；
}
公共虚拟无效更新（TEntity entityToUpdate）
{
entities.Set（）.Attach（entityToUpdate）；
context.Entry（entityToUpdate.State=EntityState.Modified；
}
公共虚拟void Save（）
{
entities.SaveChanges（）；
}
私有布尔=假；
受保护的虚拟void Dispose（bool disposing）
{
如果（！this.disposed）
{
如果（处置）
{
context.Dispose（）；
}
}
这是真的；
}
公共空间处置（）
{
处置（真实）；
总干事（本）；
}
}

服务：

public interface IRepository<TEntity> : IDisposable where TEntity : class
{

    int Count { get; }

    IEnumerable<TEntity> Get(
      Expression<Func<TEntity, bool>> filter = null,
      Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
      string includeProperties = "");

    IQueryable<TEntity> All();

    TEntity GetByID(object id);
    void Insert(TEntity entity);
    void Delete(object id);
    void Delete(TEntity entityToDelete);
    void Update(TEntity entityToUpdate);
    void Save();

}

public abstract class Repository<CEntity, TEntity> : IRepository<TEntity> where TEntity : class 
                                                                    where CEntity : DbContext, new()
{
    private CEntity entities = new CEntity();
    protected CEntity context
    {
        get { return entities; }
        set { entities = value; }
    }

    public virtual int Count 
    {
        get { return entities.Set<TEntity>().Count(); }
    }

    public virtual IEnumerable<TEntity> Get(
        Expression<Func<TEntity, bool>> filter = null,
        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
        string includeProperties = "")
    {
        IQueryable<TEntity> query = entities.Set<TEntity>();

        if (filter != null)
        {
            query = query.Where(filter);
        }

        foreach (var includeProperty in includeProperties.Split
            (new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
        {
            query = query.Include(includeProperty);
        }

        if (orderBy != null)
        {
            return orderBy(query).ToList();
        }
        else
        {
            return query.ToList();
        }
    }

    public virtual IQueryable<TEntity> All()
    {
        return entities.Set<TEntity>().AsQueryable();
    }

    public virtual TEntity GetByID(object id)
    {
        return entities.Set<TEntity>().Find(id);
    }

    public virtual void Insert(TEntity entity)
    {
        entities.Set<TEntity>().Add(entity);
    }

    public virtual void Delete(object id)
    {
        TEntity entityToDelete = entities.Set<TEntity>().Find(id);
        Delete(entityToDelete);
    }

    public virtual void Delete(TEntity entityToDelete)
    {
        if (context.Entry(entityToDelete).State == EntityState.Detached)
        {
            entities.Set<TEntity>().Attach(entityToDelete);
        }
        entities.Set<TEntity>().Remove(entityToDelete);
    }

    public virtual void Update(TEntity entityToUpdate)
    {
        entities.Set<TEntity>().Attach(entityToUpdate);
        context.Entry(entityToUpdate).State = EntityState.Modified;
    }

    public virtual void Save()
    {
        entities.SaveChanges();
    }

    private bool disposed = false;

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                context.Dispose();
            }
        }
        this.disposed = true;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}

public class CampaignService : ICampaignService 
{
    private readonly IRepository<Campaign> _campaignRepository;

    public CampaignService(IRepository<Campaign> campaignRepository)
    {
        _campaignRepository = campaignRepository;
    }

    public Campaign GetLatestCampaign()
    {
        var query = _campaignRepository.Get(x => x.CreatedOn != null, q => q.OrderByDescending(s => s.CreatedOn));
        Campaign result = query.First();

        return result;
    }

}

public interface ICampaignService
{
    Campaign GetLatestCampaign();
}

公共类活动服务：ICampaignService
{
私有只读IRepository存储库；
公共活动服务（IRepository CampaignService存储库）
{
_活动存储库=活动存储库；
}
公共活动GetLatestCampaign（）
{
var query=_activerepository.Get（x=>x.CreatedOn！=null，q=>q.OrderByDescending（s=>s.CreatedOn））；
活动结果=query.First（）；
返回结果；
}
}
公共接口ICampaignService
{
活动GetLatestCampaign（）；
}

但是很明显，我无法在控制器中获得泛型属性：

public interface IRepository<TEntity> : IDisposable where TEntity : class
{

    int Count { get; }

    IEnumerable<TEntity> Get(
      Expression<Func<TEntity, bool>> filter = null,
      Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
      string includeProperties = "");

    IQueryable<TEntity> All();

    TEntity GetByID(object id);
    void Insert(TEntity entity);
    void Delete(object id);
    void Delete(TEntity entityToDelete);
    void Update(TEntity entityToUpdate);
    void Save();

}

public abstract class Repository<CEntity, TEntity> : IRepository<TEntity> where TEntity : class 
                                                                    where CEntity : DbContext, new()
{
    private CEntity entities = new CEntity();
    protected CEntity context
    {
        get { return entities; }
        set { entities = value; }
    }

    public virtual int Count 
    {
        get { return entities.Set<TEntity>().Count(); }
    }

    public virtual IEnumerable<TEntity> Get(
        Expression<Func<TEntity, bool>> filter = null,
        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
        string includeProperties = "")
    {
        IQueryable<TEntity> query = entities.Set<TEntity>();

        if (filter != null)
        {
            query = query.Where(filter);
        }

        foreach (var includeProperty in includeProperties.Split
            (new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
        {
            query = query.Include(includeProperty);
        }

        if (orderBy != null)
        {
            return orderBy(query).ToList();
        }
        else
        {
            return query.ToList();
        }
    }

    public virtual IQueryable<TEntity> All()
    {
        return entities.Set<TEntity>().AsQueryable();
    }

    public virtual TEntity GetByID(object id)
    {
        return entities.Set<TEntity>().Find(id);
    }

    public virtual void Insert(TEntity entity)
    {
        entities.Set<TEntity>().Add(entity);
    }

    public virtual void Delete(object id)
    {
        TEntity entityToDelete = entities.Set<TEntity>().Find(id);
        Delete(entityToDelete);
    }

    public virtual void Delete(TEntity entityToDelete)
    {
        if (context.Entry(entityToDelete).State == EntityState.Detached)
        {
            entities.Set<TEntity>().Attach(entityToDelete);
        }
        entities.Set<TEntity>().Remove(entityToDelete);
    }

    public virtual void Update(TEntity entityToUpdate)
    {
        entities.Set<TEntity>().Attach(entityToUpdate);
        context.Entry(entityToUpdate).State = EntityState.Modified;
    }

    public virtual void Save()
    {
        entities.SaveChanges();
    }

    private bool disposed = false;

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                context.Dispose();
            }
        }
        this.disposed = true;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}

public class CampaignService : ICampaignService 
{
    private readonly IRepository<Campaign> _campaignRepository;

    public CampaignService(IRepository<Campaign> campaignRepository)
    {
        _campaignRepository = campaignRepository;
    }

    public Campaign GetLatestCampaign()
    {
        var query = _campaignRepository.Get(x => x.CreatedOn != null, q => q.OrderByDescending(s => s.CreatedOn));
        Campaign result = query.First();

        return result;
    }

}

public interface ICampaignService
{
    Campaign GetLatestCampaign();
}

我是否必须重复服务中的所有存储库功能？但它不是从DbContext中检索，而是从repo中获取

好像有很多重复代码，你不觉得吗

---

或者，您是否应该重复代码，但不使服务通用，并具体说明该服务正在做什么-即

\u activationservice.AddCampaign（c）而不是
\u活动服务。添加（c）
这是一个反腐败层，所以是的，您必须重新定义合同

这样想：

通用存储库接口有一个任务：隐藏有关如何持久化和检索实体的任何实现细节

服务接口有一个任务：表示用例

起初，两种情况下似乎都会暴露出相同的方法；然而，除了最简单的CRUD应用程序外，这种情况很少成立。例如，您的服务接口可以公开多种向系统添加用户的方法，但是这些方法的实现只需在存储库接口中调用lone
Insert
方法

考虑这一点的另一种方式是：如果您的服务接口看起来与存储库接口完全相同，那么这是偶然的。您应该根据您正在使用的代码，尝试将您的思维转向持久性语言（
Insert
）或服务性语言（
AddUser
）。
我们使用基本存储库和基本服务来减少冗余代码的数量，因此，我们的具体实现中只包含所需的附加方法

每个存储库一开始都是这样的，并根据需要进行扩展。
注意：ModelBase是我们在所有模型上使用的一个简单的基础模型。包含诸如
ID
，
LastU之类的内容