Unit of work + Repository

（Unit of work + Repository）

今日后开启进阶模式！

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

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

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

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

 

1 /// <summary>
2 /// 基础仓储类型接口
3 /// 采用泛型类接口定义
4 /// </summary>
5 /// <typeparam name="T">泛型参数</typeparam>
6 public interface IRepository<T> : IDisposable where T : class
7 {
8 /// <summary>
9 /// 返回当前表的所有记录
10 /// </summary>
11 /// <returns>T</returns>
12 IQueryable<T> Entries();
13
14 /// <summary>
15 /// 通过过滤条件进行查询
16 /// </summary>
17 /// <param name="predicate">过滤条件表达式</param>
18 /// <returns>T</returns>
19 IQueryable<T> Filter(Expression<Func<T, bool>> predicate);
20
21 /// <summary>
22 /// 通过过滤条件进行查询
23 /// </summary>
24 /// <param name="predicate">过滤条件表达式</param>
25 /// <param name="includes">需贪婪加载的属性名称</param>
26 /// <returns>IQueryable</returns>
27 IQueryable<T> Filter(Expression<Func<T, bool>> predicate, params string[] includes);
28
29 /// <summary>
30 /// 是否存在满足表达式的记录
31 /// </summary>
32 /// <param name="predicate">过滤条件表达式</param>
33 /// <returns>Boolean</returns>
34 bool Contains(Expression<Func<T, bool>> predicate);
35
36 /// <summary>
37 /// 按照数据库主键查询特定的实例
38 /// </summary>
39 /// <param name="keys">主键列表</param>
40 /// <returns>T</returns>
41 T Single(params object[] keys);
42
43 /// <summary>
44 /// 按照指定表达式查询特定的实例
45 /// </summary>
46 /// <param name="predicate">过滤条件表达式</param>
47 /// <returns>T</returns>
48 T FirstOrDefault(Expression<Func<T, bool>> predicate);
49
50 /// <summary>
51 /// 插入一条记录
52 /// </summary>
53 /// <param name="t">新实例</param>
54 /// <param name="submitImmediately">是否直接提交。默认false。</param>
55 /// <returns>T</returns>
56 T Create(T t, bool submitImmediately = false);
57
58 /// <summary>
59 /// 删除一行记录
60 /// </summary>
61 /// <param name="t">要删除的实例</param>
62 /// <param name="submitImmediately">是否直接提交。默认false。</param>
63 void Delete(T t, bool submitImmediately = false);
64
65 /// <summary>
66 /// 删除满足表达式的记录
67 /// </summary>
68 /// <param name="predicate">过滤条件表达式</param>
69 /// <param name="submitImmediately">是否直接提交。默认false。</param>
70 void Delete(Expression<Func<T, bool>> predicate, bool submitImmediately = false);
71
72 /// <summary>
73 /// 更新一条记录
74 /// </summary>
75 /// <param name="t">要更新的实例</param>
76 /// <param name="submitImmediately">是否直接提交。默认false。</param>
77 void Update(T t, bool submitImmediately = false);
78
79 /// <summary>
80 /// 获取当前实例的主键
81 /// </summary>
82 /// <param name="t">实例</param>
83 /// <returns>Object</returns>
84 object GetKeyValue(T t);
85 }

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

 

1 /// <summary>
2 /// 仓储类型定义
3 /// 采用泛型类定义
4 /// </summary>
5 /// <typeparam name="T">泛型参数</typeparam>
6 public class Repository<T> : IRepository<T> where T : class
7 {
8 /// <summary>
9 /// 数据库上下文
10 /// </summary>
11 public UsersContext Context { get; private set; }
12
13 /// <summary>
14 /// 当前表记录集合
15 /// </summary>
16 protected DbSet<T> DbSet
17 {
18 get
19 {
20 return Context.Set<T>();
21 }
22 }
23
24 /// <summary>
25 /// 构造器
26 /// </summary>
27 public Repository()
28 {
29 Context = new UsersContext();
30 }
31
32 /// <summary>
33 /// 构造器
34 /// </summary>
35 /// <param name="connectionString">连接字符串（名称）</param>
36 public Repository(string connectionString)
37 {
38 Context = new UsersContext(connectionString);
39 }
40
41 /// <summary>
42 /// 构造器
43 /// </summary>
44 /// <param name="context">数据库上下文</param>
45 public Repository(UsersContext context)
46 {
47 Context = context;
48 }
49
50 /// <summary>
51 /// 析构器
52 /// </summary>
53 public void Dispose()
54 {
55 if (Context != null)
56 Context.Dispose();
57 }
58
59 /// <summary>
60 /// 返回当前表的所有记录
61 /// </summary>
62 /// <returns></returns>
63 public IQueryable<T> Entries()
64 {
65 return DbSet.AsQueryable();
66 }
67
68 /// <summary>
69 /// 通过过滤条件进行查询
70 /// </summary>
71 /// <param name="predicate">过滤条件表达式</param>
72 /// <returns>T</returns>
73 public IQueryable<T> Filter(Expression<Func<T, bool>> predicate)
74 {
75 return DbSet.Where(predicate);
76 }
77
78 /// <summary>
79 /// 通过过滤条件进行查询
80 /// </summary>
81 /// <param name="predicate">过滤条件表达式</param>
82 /// <param name="includes">需贪婪加载的属性名称</param>
83 /// <returns>IQueryable</returns>
84 public IQueryable<T> Filter(Expression<Func<T, bool>> predicate, params string[] includes)
85 {
86 var query = DbSet.Where(predicate);
87 if (includes != null)
88 {
89 foreach (var item in includes)
90 {
91 query = query.Include(item);
92 }
93 }
94 return query;
95 }
96
97 /// <summary>
98 /// 是否存在满足表达式的记录
99 /// </summary>
100 /// <param name="predicate">过滤条件表达式</param>
101 /// <returns>Boolean</returns>
102 public bool Contains(Expression<Func<T, bool>> predicate)
103 {
104 return DbSet.Count(predicate) > 0;
105 }
106
107 /// <summary>
108 /// 按照数据库主键查询特定的实例
109 /// </summary>
110 /// <param name="keys">主键列表</param>
111 /// <returns>T</returns>
112 public T Single(params object[] keys)
113 {
114 return DbSet.Find(keys);
115 }
116
117 /// <summary>
118 /// 按照指定表达式查询特定的实例
119 /// </summary>
120 /// <param name="predicate">过滤条件表达式</param>
121 /// <returns>T</returns>
122 public T FirstOrDefault(Expression<Func<T, bool>> predicate)
123 {
124 return DbSet.FirstOrDefault(predicate);
125 }
126
127 /// <summary>
128 /// 插入一条记录
129 /// </summary>
130 /// <param name="t">新实例</param>
131 /// <param name="submitImmediately">是否直接提交。默认false。</param>
132 /// <returns>T</returns>
133 public T Create(T t, bool submitImmediately = false)
134 {
135 var newEntry = DbSet.Add(t);
136 if (submitImmediately)
137 Context.SaveChanges();
138 return newEntry;
139 }
140
141 /// <summary>
142 /// 删除一行记录
143 /// </summary>
144 /// <param name="t">要删除的实例</param>
145 /// <param name="submitImmediately">是否直接提交。默认false。</param>
146 public void Delete(T t, bool submitImmediately = false)
147 {
148 DbSet.Remove(t);
149 if (submitImmediately)
150 Context.SaveChanges();
151 }
152
153 /// <summary>
154 /// 删除满足表达式的记录
155 /// </summary>
156 /// <param name="predicate">过滤条件表达式</param>
157 /// <param name="submitImmediately">是否直接提交。默认false。</param>
158 public void Delete(Expression<Func<T, bool>> predicate, bool submitImmediately = false)
159 {
160 try
161 {
162 Context.Configuration.AutoDetectChangesEnabled = false; //关闭数据库上下文的自动更新跟踪功能，可提高批量操作的性能
163
164 var objects = Filter(predicate);
165 foreach (var obj in objects)
166 DbSet.Remove(obj);
167 if (submitImmediately)
168 Context.SaveChanges();
169 }
170 finally
171 {
172 Context.Configuration.AutoDetectChangesEnabled = true; //完成批量操作后，打开数据库上下文的自动更新跟踪功能
173 }
174 }
175
176 /// <summary>
177 /// 更新一条记录
178 /// </summary>
179 /// <param name="t">要更新的实例</param>
180 /// <param name="submitImmediately">是否直接提交。默认false。</param>
181 public void Update(T t, bool submitImmediately = false)
182 {
183 var key = GetKeyValue(t);
184
185 var originalEntity = DbSet.Find(key);
186
187 Context.Entry(originalEntity).CurrentValues.SetValues(t);
188
189 if (submitImmediately)
190 Context.SaveChanges();
191 }
192
193 /// <summary>
194 /// 获取当前实例的主键
195 /// </summary>
196 /// <param name="t">实例</param>
197 /// <returns>Object</returns>
198 public object GetKeyValue(T t)
199 {
200 var key =
201 typeof(T).GetProperties().FirstOrDefault(
202 p => p.GetCustomAttributes(typeof(System.ComponentModel.DataAnnotations.KeyAttribute), true).Length != 0);
203 return (key != null) ? key.GetValue(t, null) : null;
204 }
205 }

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

　　接下来就是我们的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如何工作，大家不必太较真。

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

 

分类: .NET MVC

标签: MVC, EntityFramework, CodeFirst, Unit of work, Repositry