EntityFramework用法探索（四）Repository和UnitOfWork

以上一篇CodeFirst生成代码为基础，继续探索使用方式。

引入Repository模式，定义最简单的IRepository接口，仅包含增删改查接口，

  public interface IRepository<T>
    where T : class
  {
    IQueryable<T> Query();
    void Insert(T entity);
    void Update(T entity);
    void Delete(T entity);
  }

引入UnitOfWork模式，因为EntityFramework会负责失败回滚，所以此处只定义提交方法。

  public interface IUnitOfWork
  {
    void Commit();
  }

实现IRepository接口，

  public class Repository<T> : IRepository<T> where T : class
  {
    private readonly IObjectSetFactory _objectSetFactory;
    private readonly IObjectSet<T> _objectSet;

    public Repository(IObjectSetFactory objectSetFactory)
    {
      _objectSetFactory = objectSetFactory;
      _objectSet = objectSetFactory.CreateObjectSet<T>();
    }

    #region IRepository<T> Members

    public IQueryable<T> Query()
    {
      return _objectSet;
    }

    public void Insert(T entity)
    {
      _objectSet.AddObject(entity);
    }

    public void Update(T entity)
    {
      _objectSet.Attach(entity);
      _objectSetFactory.ChangeObjectState(entity, EntityState.Modified);
    }

    public void Delete(T entity)
    {
      _objectSet.DeleteObject(entity);
    }

    #endregion
  }

实现IUnitOfWork接口，

  public class UnitOfWork : IUnitOfWork, IDisposable
  {
    private readonly IObjectContext _objectContext;

    public UnitOfWork(IObjectContext objectContext)
    {
      _objectContext = objectContext;
    }

    #region IUnitOfWork Members

    public void Commit()
    {
      _objectContext.SaveChanges();
    }

    #endregion

    #region IDisposable Members

    public void Dispose()
    {
      if (_objectContext != null)
      {
        _objectContext.Dispose();
      }

      GC.SuppressFinalize(this);
    }

    #endregion
  }

CustomerRepository类的实现需要做一些配置，

    public CustomerRepository()
    {
      Mapper.CreateMap<DomainModels.Customer, Customer>();
      Mapper.CreateMap<Customer, DomainModels.Customer>();

      DbContext context = new RETAILContext();
      DbContextAdapter contextAdaptor = new DbContextAdapter(context);

      IObjectSetFactory objectSetFactory = contextAdaptor;
      _repository = new Repository<Customer>(objectSetFactory);

      IObjectContext objectContext = contextAdaptor;
      _uow = new UnitOfWork(objectContext);
    }

则具体增删改查的逻辑实现，

    public void InsertCustomer(DomainModels.Customer customer)
    {
      Customer entity = Mapper.Map<DomainModels.Customer, Customer>(customer);

      _repository.Insert(entity);
      _uow.Commit();

      customer.Id = entity.Id;
    }

    public void UpdateCustomer(DomainModels.Customer customer)
    {
      Customer entity = _repository.Query().Single(c => c.Id == customer.Id);

      entity.Name = customer.Name;
      entity.Address = customer.Address;
      entity.Phone = customer.Phone;

      _repository.Update(entity);

      _uow.Commit();
    }

在同样的示例下仍然可以工作，

      ICustomerRepository customerRepository = new CustomerRepository();

      // =============== 增 ===============
      Console.ForegroundColor = ConsoleColor.DarkRed;

      DomainModels.Customer customer1 = new DomainModels.Customer()
      {
        Name = "Dennis Gao",
        Address = "Beijing",
        Phone = "18888888888",
      };
      customerRepository.InsertCustomer(customer1);
      Console.WriteLine(customer1);

同时，UnitOfWork可以保证相关的业务操作在同一个Transaction中，

完整代码和索引

EntityFramework用法探索系列

• （一）DatabaseFirst
• （二）CodeFirst
• （三）CodeFirst流畅API
• （四）Repository和UnitOfWork
• （五）引入Unity
• （六）静态Repository
• （七）线程安全实践
• （八）事务处理

完整代码下载