.NET MVC4 实训记录之四（Unit of work + Repository）

　　今日后开启进阶模式！

　　谈到MVC与EntityFramework，则不得不说一说事务与仓储（Unit of work + Repository）。

　　仓储（Repository）：领域对象集合。用于操作领域对象与数据库上下文（DbContext）的交互（在此不得不说一声，领域对象和数据库表对象还是有区别的。领域对象实际上是一组有业务关系的数据库对象的抽象。最简单的形式就是主表、关系表在同一个领域对象中进行定义。例如我们前几章看到的UserProfile，它即定义了用户信息，又定义了用户角色关系信息）。

　　事务（Transaction）：多个业务处理有必然的顺序性、依赖性，则默认这些业务为一个原子操作。在这里我们使用工作单元，即Unit of work模式，来维护事务的原子性。

　　首先，先让我们构建仓储接口。为了更好的使用EntityFramework的延迟加载，所有查询集合的接口我们均使用IQueryable接口类型作为返回值。

       /// <summary>
       /// 基础仓储类型接口
       /// 采用泛型类接口定义
       /// </summary>
       /// <typeparam name="T">泛型参数</typeparam>
       public interface IRepository<T> : IDisposable where T : class
       {
           /// <summary>
           /// 返回当前表的所有记录
          /// </summary>
          /// <returns>T</returns>
          IQueryable<T> Entries();

          /// <summary>
          /// 通过过滤条件进行查询
          /// </summary>
          /// <param name="predicate">过滤条件表达式</param>
          /// <returns>T</returns>
          IQueryable<T> Filter(Expression<Func<T, bool>> predicate);

          /// <summary>
          /// 通过过滤条件进行查询
          /// </summary>
          /// <param name="predicate">过滤条件表达式</param>
          /// <param name="includes">需贪婪加载的属性名称</param>
          /// <returns>IQueryable</returns>
          IQueryable<T> Filter(Expression<Func<T, bool>> predicate, params string[] includes);

          /// <summary>
          /// 是否存在满足表达式的记录
          /// </summary>
          /// <param name="predicate">过滤条件表达式</param>
          /// <returns>Boolean</returns>
          bool Contains(Expression<Func<T, bool>> predicate);

          /// <summary>
          /// 按照数据库主键查询特定的实例
          /// </summary>
          /// <param name="keys">主键列表</param>
          /// <returns>T</returns>
          T Single(params object[] keys);

          /// <summary>
          /// 按照指定表达式查询特定的实例
          /// </summary>
          /// <param name="predicate">过滤条件表达式</param>
          /// <returns>T</returns>
          T FirstOrDefault(Expression<Func<T, bool>> predicate);

          /// <summary>
          /// 插入一条记录
          /// </summary>
          /// <param name="t">新实例</param>
          /// <param name="submitImmediately">是否直接提交。默认false。</param>
          /// <returns>T</returns>
          T Create(T t, bool submitImmediately = false);

          /// <summary>
          /// 删除一行记录
          /// </summary>
          /// <param name="t">要删除的实例</param>
          /// <param name="submitImmediately">是否直接提交。默认false。</param>
          void Delete(T t, bool submitImmediately = false);

          /// <summary>
          /// 删除满足表达式的记录
          /// </summary>
          /// <param name="predicate">过滤条件表达式</param>
          /// <param name="submitImmediately">是否直接提交。默认false。</param>
          void Delete(Expression<Func<T, bool>> predicate, bool submitImmediately = false);

          /// <summary>
          /// 更新一条记录
          /// </summary>
          /// <param name="t">要更新的实例</param>
          /// <param name="submitImmediately">是否直接提交。默认false。</param>
          void Update(T t, bool submitImmediately = false);

          /// <summary>
          /// 获取当前实例的主键
          /// </summary>
          /// <param name="t">实例</param>
          /// <returns>Object</returns>
          object GetKeyValue(T t);
      }

　　接下来是实现这个接口，真正去处理数据查询和操作的时候了。

       /// <summary>
        /// 仓储类型定义
        /// 采用泛型类定义
        /// </summary>
        /// <typeparam name="T">泛型参数</typeparam>
        public class Repository<T> : IRepository<T> where T : class
        {
            /// <summary>
            /// 数据库上下文
           /// </summary>
           public UsersContext Context { get; private set; }

           /// <summary>
           /// 当前表记录集合
           /// </summary>
           protected DbSet<T> DbSet
           {
               get
               {
                   return Context.Set<T>();
               }
           }

           /// <summary>
           /// 构造器
           /// </summary>
           public Repository()
           {
               Context = new UsersContext();
           }

           /// <summary>
           /// 构造器
           /// </summary>
           /// <param name="connectionString">连接字符串（名称）</param>
           public Repository(string connectionString)
           {
               Context = new UsersContext(connectionString);
           }

           /// <summary>
           /// 构造器
           /// </summary>
           /// <param name="context">数据库上下文</param>
           public Repository(UsersContext context)
           {
               Context = context;
           }

           /// <summary>
           /// 析构器
           /// </summary>
           public void Dispose()
           {
               if (Context != null)
                   Context.Dispose();
           }

           /// <summary>
           /// 返回当前表的所有记录
           /// </summary>
           /// <returns></returns>
           public IQueryable<T> Entries()
           {
               return DbSet.AsQueryable();
           }

           /// <summary>
           /// 通过过滤条件进行查询
           /// </summary>
           /// <param name="predicate">过滤条件表达式</param>
           /// <returns>T</returns>
           public IQueryable<T> Filter(Expression<Func<T, bool>> predicate)
           {
               return DbSet.Where(predicate);
           }

           /// <summary>
           /// 通过过滤条件进行查询
           /// </summary>
           /// <param name="predicate">过滤条件表达式</param>
           /// <param name="includes">需贪婪加载的属性名称</param>
           /// <returns>IQueryable</returns>
           public IQueryable<T> Filter(Expression<Func<T, bool>> predicate, params string[] includes)
           {
               var query = DbSet.Where(predicate);
               if (includes != null)
               {
                   foreach (var item in includes)
                   {
                       query = query.Include(item);
                   }
               }
               return query;
           }

           /// <summary>
           /// 是否存在满足表达式的记录
           /// </summary>
          /// <param name="predicate">过滤条件表达式</param>
          /// <returns>Boolean</returns>
          public bool Contains(Expression<Func<T, bool>> predicate)
          {
              return DbSet.Count(predicate) > ;
          }

          /// <summary>
          /// 按照数据库主键查询特定的实例
          /// </summary>
          /// <param name="keys">主键列表</param>
          /// <returns>T</returns>
          public T Single(params object[] keys)
          {
              return DbSet.Find(keys);
          }

          /// <summary>
          /// 按照指定表达式查询特定的实例
          /// </summary>
          /// <param name="predicate">过滤条件表达式</param>
          /// <returns>T</returns>
          public T FirstOrDefault(Expression<Func<T, bool>> predicate)
          {
              return DbSet.FirstOrDefault(predicate);
          }

          /// <summary>
          /// 插入一条记录
          /// </summary>
          /// <param name="t">新实例</param>
          /// <param name="submitImmediately">是否直接提交。默认false。</param>
          /// <returns>T</returns>
          public T Create(T t, bool submitImmediately = false)
          {
              var newEntry = DbSet.Add(t);
              if (submitImmediately)
                  Context.SaveChanges();
              return newEntry;
          }

          /// <summary>
          /// 删除一行记录
          /// </summary>
          /// <param name="t">要删除的实例</param>
          /// <param name="submitImmediately">是否直接提交。默认false。</param>
          public void Delete(T t, bool submitImmediately = false)
          {
              DbSet.Remove(t);
              if (submitImmediately)
                  Context.SaveChanges();
          }

          /// <summary>
          /// 删除满足表达式的记录
          /// </summary>
          /// <param name="predicate">过滤条件表达式</param>
          /// <param name="submitImmediately">是否直接提交。默认false。</param>
          public void Delete(Expression<Func<T, bool>> predicate, bool submitImmediately = false)
          {
              try
              {
                  Context.Configuration.AutoDetectChangesEnabled = false; //关闭数据库上下文的自动更新跟踪功能，可提高批量操作的性能

                  var objects = Filter(predicate);
                  foreach (var obj in objects)
                      DbSet.Remove(obj);
                  if (submitImmediately)
                      Context.SaveChanges();
              }
              finally
              {
                  Context.Configuration.AutoDetectChangesEnabled = true; //完成批量操作后，打开数据库上下文的自动更新跟踪功能
              }
          }

          /// <summary>
          /// 更新一条记录
          /// </summary>
          /// <param name="t">要更新的实例</param>
          /// <param name="submitImmediately">是否直接提交。默认false。</param>
          public void Update(T t, bool submitImmediately = false)
          {
              var key = GetKeyValue(t);

              var originalEntity = DbSet.Find(key);

              Context.Entry(originalEntity).CurrentValues.SetValues(t);

              if (submitImmediately)
                  Context.SaveChanges();
          }

          /// <summary>
          /// 获取当前实例的主键
          /// </summary>
          /// <param name="t">实例</param>
          /// <returns>Object</returns>
          public object GetKeyValue(T t)
          {
              var key =
                  typeof(T).GetProperties().FirstOrDefault(
                      p => p.GetCustomAttributes(typeof(System.ComponentModel.DataAnnotations.KeyAttribute), true).Length != );
              return (key != null) ? key.GetValue(t, null) : null;
          }
      }

　　仓储定义完成。它包含了基本的增、删、改、查功能。无需过多的修饰，作为仓储单元，它的任务就是这么四个操作而已。

　　接下来就是我们的Unit of work的定义了。

 namespace Framework.Repositories
 {
     /// <summary>
     /// 工作单元接口定义
     /// </summary>
     public interface IUnitOfWork: IDisposable
     {
         /// <summary>
         /// 获取数据库上下文
         /// </summary>
         UsersContext DbContext { get; }

         /// <summary>
         /// 执行自定义SQL语句。
         /// 该方法提供了一个直接操作数据库表的实现。
         /// </summary>
         /// <param name="commandText">SQL语句</param>
         /// <param name="parameters">参数列表</param>
         /// <returns>Integer</returns>
         int ExecuteSqlCommand(string commandText, params object[] parameters);

         /// <summary>
         /// 提交事务
         /// </summary>
         /// <returns>Integer</returns>
         int Commit();

         /// <summary>
         /// 获取指定类型的仓储实例
         /// </summary>
         /// <typeparam name="T">泛型参数</typeparam>
         /// <returns>IRepository</returns>
         IRepository<T> Repositry<T>() where T : class;
     }

     /// <summary>
     /// 工作单元实现定义
     /// </summary>
     public class UnitOfWork : IUnitOfWork
     {
         /// <summary>
         /// 用户数据库上下文
         /// </summary>
         private UsersContext dbContext = null;

         /// <summary>
         /// 获取数据库上下文
         /// </summary>
         public UsersContext DbContext { get { return dbContext; } }

         /// <summary>
         /// 构造器
         /// </summary>
         public UnitOfWork()
         {
             dbContext = new UsersContext();
         }

         /// <summary>
         /// 构造器
         /// </summary>
         /// <param name="context">数据库上下文</param>
         public UnitOfWork(UsersContext context)
         {
             dbContext = context;
         }

         /// <summary>
         /// 析构器
         /// </summary>
         public void Dispose()
         {
             if (dbContext != null)
                 dbContext.Dispose();
             GC.SuppressFinalize(this);
         }

         /// <summary>
         /// 获取指定类型的仓储实例
         /// </summary>
         /// <typeparam name="T">泛型参数</typeparam>
         /// <returns>IRepository</returns>
         public IRepository<T> Repositry<T>() where T : class
         {
             return new Repository<T>(DbContext);
         }

         /// <summary>
         /// 提交事务
         /// </summary>
         /// <returns>Integer</returns>
         public int Commit()
         {
             return dbContext.SaveChanges();
         }

         /// <summary>
         /// 执行自定义SQL语句。
         /// 该方法提供了一个直接操作数据库表的实现。
         /// </summary>
         /// <param name="commandText">SQL语句</param>
         /// <param name="parameters">参数列表</param>
         /// <returns>Integer</returns>
         public int ExecuteSqlCommand(string commandText, params object[] parameters)
         {
             return dbContext.Database.ExecuteSqlCommand(commandText, parameters);
         }
     }
 }

　

　　OK，基础类型的定义已经完成，看看我们如何使用它吧。先模拟一个场景：当前要添加一个用户，同时在添加用户的时候，要吧该用户增加到指定的部门列表（UserDepartment）下。

         public void AddNewUser(string userName, string department)
         {
             using (IUnitOfWork unit = new UnitOfWork())
             {
                 //获取用户类型的仓储
                 var usrRep = unit.Repositry<UserProfile>();
                 //创建新用户
                 var User = new UserProfile { UserName = userName };

                 //将用户信息添加到数据库。
                 //注意：我们没有使用Create接口的第二个参数，即表示第二个参数默认为false，这表示当前操作暂时不提交到数据库。
                 //如果使用 usrRep.Create(User, true), 则表示直接提交当前记录到数据库。
                 //假如有兴趣，可以尝试第二个参数为true，执行该句之后人为抛出一个异常，看看数据库是如何发生变化的。
                 usrRep.Create(User);

                 //throw new Exception("");

                 //获取部门类型的仓储
                 var depRep = unit.Repositry<Department>();
                 //根据部门名称获取部门信息
                 var Department = depRep.FirstOrDefault(p => p.Name.Equals(department));
                 //将当前用户添加到该部门内
                 Department.DepartmentUsers.Add(new UserDepartment { UserId = User.UserId, DepartmentId = Department.Id });

                 //提交前面所有的操作。这个才是最关键的。没有这句，一切都是瞎忙活！！！
                 unit.Commit();
             }
         }

　　当然，通常我们不会这么去做。我们会在UserProfile的定义中添加一个Department集合，同样会在Department中添加一个UserProfile集合，构建用户与部门的多对多关系（EntityFramework的多种数据映射关系以后我们会提到，网上相应的资料也很多），这样就可以很容易的只是用用户仓储实例进行操作，只需一个usrRep.Create(User, true)操作就可以完成上面的业务。不过我们只是为了说明Unitofwork如何工作，大家不必太较真。

　　好了，今天就此结束。希望我能坚持不懈，也希望大家能一起见证我们努力的结果。