Question

这是我处理存储库模式的一周，我以某种方式实现了通用存储库：

private CentralEntities db = null;
private DbSet<T> table = null;

public RepositoryTest() 
{
    this.db = new CentralEntities();
    table = db.Set<T>();
}

public RepositoryTest(CentralEntities db)
{

    this.db = db;
    table = db.Set<T>();
}
public IEnumerable<T> SelectAll()
{           
    return table.Take(10).ToList();
}

这是我的IRepository：

public  interface IRepositoryTest<T> where T:class
{
    IEnumerable<T> SelectAll();
}

在我的控制器中，我实现了以下内容，并且可以正常工作：

public class DashbrdController : Controller
{

    IRepositoryTest<Event> _repository = null;

    public DashbrdController(IRepositoryTest<Event> _repository)
    {
        this._repository = _repository;
    }

    public DashbrdController()
    {
       this._repository = new RepositoryTest<Event>();
    }

    public ActionResult DashBrd()
    {
        var rslt= _repository.SelectAll().Take(10); 
        return View(rslt);

    }
}

首先，我不如何实现Iunitofwork和UnitOfWork，其次，除了创建用于更新或插入的单个门外，UnitOfWork的用途是什么？上面的示例可以解决什么问题？

Answer 1

有关UOW和存储库的详细信息，请参阅以下部分：

1）您创建通用存储库（所有数据源的基础）：

公共类GenericRepository：IGenericRepository其中T：课

{
    protected DbContext _entities;
    protected readonly IDbSet<T> _dbset;

    public GenericRepository(DbContext context)
    {
        _entities = context;
        _dbset = context.Set<T>();
    }


    public IEnumerable<T> GetAll()
    {
        return _dbset.AsEnumerable();
    }

    public IEnumerable<T> FindBy(System.Linq.Expressions.Expression<Func<T, bool>> predicate)
    {
        IEnumerable<T> query = _dbset.Where(predicate).AsEnumerable();
        return query;
    }

    public virtual T GetSingle(System.Linq.Expressions.Expression<Func<T, bool>> predicate)
    {
        T query = _dbset.Where(predicate).FirstOrDefault();
        return query;
    }

    public virtual void Add(T entity)
    {
        _dbset.Add(entity);
    }


    public virtual void Delete(T entity)
    {
        _dbset.Remove(entity);            
    }

    public virtual void Edit(T entity)
    {
        _entities.Entry(entity).State = EntityState.Modified;


    }
    public virtual void Attach(T entity)
    {            
        _dbset.Attach(entity);
    }

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

2）然后创建一个工作单元（添加存储库实例的通用单元）

公共密封类GenericUnitOfWork：IGenericUnitOfWork，IDisposable

{
    private ApplicationDbContext entities = null;
    private ApplicationUserManager _userManager;


    public GenericUnitOfWork()
    {
        entities = new ApplicationDbContext();
    }


    public Dictionary<Type, object> repositories = new Dictionary<Type, object>();

    public IGenericRepository<T> Repository<T>() where T : class
    {
        if (repositories.Keys.Contains(typeof(T)) == true)
        {
            return repositories[typeof(T)] as IGenericRepository<T>;
        }
        IGenericRepository<T> repo = new GenericRepository<T>(entities);
        repositories.Add(typeof(T), repo);
        return repo;
    }


    public int Commit()
    {
        return entities.SaveChanges();
    }

    private bool disposed = false;

    private void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                entities.Dispose();
            }
        }
        this.disposed = true;
    }

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



}

3）然后，您从控制器调用UnitOfWork，该控制器以通用形式创建存储库实例

 public class DashbrdController : Controller
    {
        private GenericUnitOfWork uow = null;

        public DashbrdController()
        {
            uow = new GenericUnitOfWork();
        }

        public ActionResult DashBrd()
        {
            var rslt = uow.Repository<Event>().GetAll().ToList();
            return View(rslt);

        }
    }

工作单元类通过创建由所有存储库共享的单个数据库上下文类来协调多个存储库的工作。

对于特定的用户操作（例如添加事件），所有事务（例如插入/更新/删除等）都在一个事务中完成，而不是在多个数据库中进行事务。这意味着，这里的一个工作单元涉及插入/更新/删除操作，全部都在一个事务中。

请使用上面提供的实现类创建接口。让我知道是否发生问题。

希望有帮助。

关于在存储库模式中使用UnitOfWork的困惑

1 个答案: