[asp.net] 각 객체에 대해 일반 리포지토리와 특정 리포지토리를 만들면 어떤 이점이 있습니까?

ASP.NET MVC 응용 프로그램을 개발 중이며 이제 리포지토리 / 서비스 클래스를 구축하고 있습니다. 모든 리포지토리가 구현하는 일반 IRepository 인터페이스를 만드는 것과 각 리포지토리에 고유 한 인터페이스와 메서드 집합이있는 주요 이점이 있는지 궁금합니다.

예를 들어, 일반적인 IRepository 인터페이스는 다음과 같습니다 ( 이 답변 에서 가져옴 ).

public interface IRepository : IDisposable
{
    T[] GetAll<T>();
    T[] GetAll<T>(Expression<Func<T, bool>> filter);
    T GetSingle<T>(Expression<Func<T, bool>> filter);
    T GetSingle<T>(Expression<Func<T, bool>> filter, List<Expression<Func<T, object>>> subSelectors);
    void Delete<T>(T entity);
    void Add<T>(T entity);
    int SaveChanges();
    DbTransaction BeginTransaction();
}

각 리포지토리는이 인터페이스를 구현합니다 (예 :

• 고객 리포지토리 :이 리포지토리
• 제품 리포지토리 :이 리포지토리
• 기타

이전 프로젝트에서 수행 한 대안은 다음과 같습니다.

public interface IInvoiceRepository : IDisposable
{
    EntityCollection<InvoiceEntity> GetAllInvoices(int accountId);
    EntityCollection<InvoiceEntity> GetAllInvoices(DateTime theDate);
    InvoiceEntity GetSingleInvoice(int id, bool doFetchRelated);
    InvoiceEntity GetSingleInvoice(DateTime invoiceDate, int accountId); //unique
    InvoiceEntity CreateInvoice();
    InvoiceLineEntity CreateInvoiceLine();
    void SaveChanges(InvoiceEntity); //handles inserts or updates
    void DeleteInvoice(InvoiceEntity);
    void DeleteInvoiceLine(InvoiceLineEntity);
}

두 번째 경우, 표현식 (LINQ 또는 기타)은 리포지토리 구현에 완전히 포함되며 서비스를 구현하는 사람은 호출 할 리포지토리 함수를 알아야합니다.

서비스 클래스에서 모든 표현식 구문을 작성하고 리포지토리로 전달하는 이점을 보지 못합니다. 이것은 messup하기 쉬운 LINQ 코드가 많은 경우에 복제되고 있다는 것을 의미하지 않습니까?

예를 들어 기존 인보이스 발행 시스템에서는

InvoiceRepository.GetSingleInvoice(DateTime invoiceDate, int accountId)

몇 가지 다른 서비스 (고객, 송장, 계정 등)에서 여러 곳에서 다음을 작성하는 것보다 훨씬 깔끔해 보입니다.

rep.GetSingle(x => x.AccountId = someId && x.InvoiceDate = someDate.Date);

특정 접근 방식을 사용할 때의 유일한 단점은 Get * 함수의 많은 순열로 끝날 수 있다는 것입니다. 그러나 여전히 식 논리를 서비스 클래스로 푸시하는 것이 바람직합니다.

내가 무엇을 놓치고 있습니까?

답변

public abstract class Repository<TEntity>
{
    private DataContext _dataContext;

    protected Repository(DataContext dataContext)
    {
        _dataContext = dataContext;
    }

    protected IQueryable<TEntity> Query
    {
        get { return _dataContext.GetTable<TEntity>(); }
    }

    protected void InsertOnCommit(TEntity entity)
    {
        _dataContext.GetTable<TEntity>().InsertOnCommit(entity);
    }

    protected void DeleteOnCommit(TEntity entity)
    {
        _dataContext.GetTable<TEntity>().DeleteOnCommit(entity);
    }
}

public interface IUserRepository
{
    User GetById(int id);

    IQueryable<User> GetLockedOutUsers();

    void Insert(User user);
}

public class UserRepository : Repository<User>, IUserRepository
{
    public UserRepository(DataContext dataContext) : base(dataContext)
    {}

    public User GetById(int id)
    {
        return Query.Where(user => user.Id == id).SingleOrDefault();
    }

    public IQueryable<User> GetLockedOutUsers()
    {
        return Query.Where(user => user.IsLockedOut);
    }

    public void Insert(User user)
    {
        InsertOnCommit(user);
    }
}