Question

我即将开始一个中小型项目。我绝不是软件架构师。但我倾向于质疑我有时会做出的每一个举动。因为我想做正确的事情。

我找到了一种实现简单存储库的方法，我想知道这是否是一个正确的＆＃34;这样做的方式。我来到这个解决方案，因为我知道发生了什么，并且在我知道之前没有收集到复杂的东西:)

在这里。

工作单元

我确保将所有存储库保存在同一个dbcontext下。在我的uof中，我可以在从控制器调用它时访问所有repo。

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

这是一个存储库的简短示例，它接收dbcontext并使用它来获取我想要的任何数据

   public class ContactRepository
   {
    private ApplicationDbContext _entities;

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

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

控制器

控制器的简短示例

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

如果您的目标是简单，那么只需使用实体框架，但如果您打算使用存储库模式，我会鼓励您正确地执行此操作。

使用存储库的两个最大动力是：

您希望将CRUD应用程序简化为您的数据库。这是通过使用接口和泛型来完成
您希望能够单独测试业务逻辑来自外部依赖。再次，这是通过使用接口

下面将花两分钟时间来实施，但至少你知道你做得对，因为目前你正试图以一种无效的方式实现一个伟大的模式。

通用界面：

    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);
    }

通用存储库：

    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);
    }
}

带有实体框架的简单存储库asp.net mvc

1 个答案: