Простой репозиторий asp.net mvc с инфраструктурой сущностей

Question

Я собираюсь запустить небольшой/средний проект. Я отнюдь не архитектор программного обеспечения. Но я склонен подвергать сомнению каждый шаг, который я делаю иногда. Так как я хочу делать все правильно.

Я нашел способ реализовать простой репозиторий, и я хотел знать, является ли это «правильным» способом его выполнения. Я пришел к этому решению, так как знаю, что происходит, и не занимаюсь чем-то сложным до того, как у меня есть знания :)

Вот оно.

Единица работы

Где я убедиться, что я, чтобы сохранить все мои хранилища под то же DbContext. В моем распоряжении я могу получить доступ ко всем репо при вызове его из контроллера.

public class UnitOfWork : IDisposable 
{ 
    private ContactRepository _contactRepo; 
    private ApplicationDbContext _entities; 

    public UnitOfWork(ApplicationDbContext entities) 
    { 
     _entities = entities; 
    } 

    public ContactRepository ContactRepo 
    { 
     get 
     { 
      if (_contactRepo == null) 
      { 
       _contactRepo = new ContactRepository(_entities); 
      } 
      return _contactRepo; 
     } 
    } 


    public void Save() 
    { 
     _entities.SaveChanges(); 
    } 

    private bool disposed = false; 

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

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

ContactRepository

Это короткий пример хранилища, где он recieves в DbContext и использует его, чтобы захватить все данные, я хочу

public class ContactRepository 
    { 
    private ApplicationDbContext _entities; 

    public ContactRepository(ApplicationDbContext entities) 
    { 
     _entities = entities; 
    } 

    public IEnumerable<Contact> GetAll() 
    { 
     return _entities.Contacts; 
    } 
} 

Контроллер

Sho к.т. пример контроллера

public class ContactController : Controller 
{ 

    UnitOfWork uow = new UnitOfWork(new ApplicationDbContext()); 

    public ActionResult Index() 
    { 
     var contacts = uow.ContactRepo.GetAll(); 
     return View(contacts); 
    } 



    protected override void Dispose(bool disposing) 
    { 
     uow.Dispose(); 
     base.Dispose(disposing); 
    } 
} 

В этом случае я буду иметь доступ ко всем моим хранилищам в том же DbContext, который я был стремился.

Я знаю, что все может быть сделано умнее/различно. С помощью, например, расширяемого общего репо. Но в этом случае я стремлюсь к чему-то простому и понятному. Но все же не хотите совершать огромную ошибку, если есть серьезный недостаток.

Вы видите какие-либо серьезные недостатки в этом способе обработки данных через инфраструктуру сущности?

Answer 1

Если вы нацелены на что-то простое, просто используйте Entity Framework, но если вы собираетесь использовать шаблон репозитория, я бы рекомендовал вам сделать это правильно.

Два из крупнейших мотиваторов для использования хранилища являются:

1. Вы хотите упростить CRUD приложения для ваших database.This это делается с помощью интерфейсов и дженериков
2. Вы хотите к способность тестировать бизнес-логику в изоляции от внешних зависимостей. Как правило, это осуществляется с использованием интерфейсов .

Ниже вам потребуются две минуты, но, по крайней мере, вы знаете, что делаете это правильно, потому что на данный момент вы пытаетесь реализовать отличный шаблон неэффективным способом.

Общий интерфейс:

public interface IRepository<T> 
    { 
     T GetById(int id); 
     IEnumerable<T> List(); 
     IEnumerable<T> List(Expression<Func<T, bool>> predicate); 
     void Add(T entity); 
     void Delete(T entity); 
     void Update(T entity); 
    } 

Generic хранилище:

public abstract class EntityBase 
    { 
    } 

    public class DBRepository<T> : IRepository<T> where T : EntityBase 
    { 
     private readonly DbContext _dbContext; 

     public DBRepository(DbContext dbContext) 
     { 
      _dbContext = dbContext; 
     } 

     public virtual T GetById(int id) 
     { 
      return _dbContext.Set<T>().Find(id); 
     } 

     public virtual IEnumerable<T> List() 
     { 
      return _dbContext.Set<T>().AsEnumerable(); 
     } 

     public virtual IEnumerable<T> List(System.Linq.Expressions.Expression<Func<T, bool>> predicate) 
     { 
      return _dbContext.Set<T>() 
        .Where(predicate) 
        .AsEnumerable(); 
     } 

     public void Add(T entity) 
     { 
      _dbContext.Set<T>().Add(entity); 
     } 

     public void Update(T entity) 
     { 
      _dbContext.Entry(entity).State = EntityState.Modified; 
     } 

     public void Delete(T entity) 
     { 
      _dbContext.Set<T>().Remove(entity); 
     } 

Единица работы:

public class UnitOfWork : IDisposable 
{ 
    private bool disposed = false; 
    private ApplicationDbContext context = new ApplicationDbContext(); 

    private IRepository<Contact> _contactRepository; 

    public IRepository<Contact> ContactRepository 
    { 
     get 
     { 
      if (this._contactRepository == null) 
       this._contactRepository = new DBRepository<Contact>(context); 
      return _contactRepository; 
     } 
    } 

    public void Save() 
    { 
     context.SaveChanges(); 
    } 

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

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