EF6中使用事务的方法

默认情况当你执行SaveChanges()的时候（insert update delete）来操作数据库时，Entity Framework会把这个操作包装在一个事务里，当操作结束后，事务也结束了。

EF6中的 Database.ExecuteSqlCommand()也会启用一个事务，事务的隔离级别是默认级别（Read Commited）。

虽然这种框架默认的事务处理机制对于大多数情况下已经够用了，但是是EF6为我们提供了API，让我们能够更加灵活地对自己代码中的事务进行控制。

一、在EF中使用事务

1. using System;
2. using System.Collections.Generic;
3. using System.Data.Entity;
4. using System.Data.SqlClient;
5. using System.linq;
6. using System.Transactions;
8. namespace TransactionsExamples
9. {
10. class TransactionsExample
11. {
12. static void StartOwnTransactionWithinContext()
13. {
14. using (var context = new BloggingContext())
15. {
16. using (var dbContextTransaction = context.Database.BeginTransaction())
17. {
18. try
19. {
20. context.Database.ExecuteSqlCommand(
21. @"UPDATE Blogs SET Rating = 5" +
22. " WHERE Name LIKE '%Entity Framework%'"
23. );
25. var query = context.Posts.Where(p => p.Blog.Rating >= 5);
26. foreach (var post in query)
27. {
28. post.Title += "[Cool Blog]";
29. }
31. context.SaveChanges();
33. dbContextTransaction.Commit();
34. }
35. catch (Exception)
36. {
37. dbContextTransaction.Rollback();
38. }
39. }
40. }
41. }
42. }
43. }

上面通过一个using语句块把要使用事务的操作起来，调用context.Database.BeginTransaction()启动一个事务，最后分别通过dbContextTransaction.Commit();和dbContextTransaction.Rollback();来提交或回滚事务。

注意：开启一个事务需要事务所有在的数据库链接是打开的，因此当所在数据库链接没有打开时Database.BeginTransaction()就会打开一个数据库链接。上面调用context.Database.BeginTransaction()是没有参数的，你可以调用这个BeginTransaction()其它重载函数来控制事务的隔离级别，如果没传参数将会使用默认的隔离级别。

二、传递一个已存在的事务

EF中可以传递一个存在的事务给context：

1. using System;
2. using System.Collections.Generic;
3. using System.Data.Entity;
4. using System.Data.SqlClient;
5. using System.Linq;
6. sing System.Transactions;
8. namespace TransactionsExamples
9. {
10. class TransactionsExample
11. {
12. static void UsingExternalTransaction()
13. {
14. using (var conn = new SqlConnection("..."))
15. {
16. conn.Open();
18. using (var sqlTxn = conn.BeginTransaction(System.Data.IsolationLevel.Snapshot))
19. {
20. try
21. {
22. var sqlCommand = new SqlCommand();
23. sqlCommand.Connection = conn;
24. sqlCommand.Transaction = sqlTxn;
25. sqlCommand.CommandText =
26. @"UPDATE Blogs SET Rating = 5" +
27. " WHERE Name LIKE '%Entity Framework%'";
28. sqlCommand.ExecuteNonQuery();
30. using (var context =
31. new BloggingContext(conn, contextOwnsConnection: false))
32. {
33. context.Database.UseTransaction(sqlTxn);
35. var query = context.Posts.Where(p => p.Blog.Rating >= 5);
36. foreach (var post in query)
37. {
38. post.Title += "[Cool Blog]";
39. }
40. context.SaveChanges();
41. }
43. sqlTxn.Commit();
44. }
45. catch (Exception)
46. {
47. sqlTxn.Rollback();
48. }
49. }
50. }
51. }
52. }
53. }

  

三、TransactionScope事务

EF中让多个数据库操作作为一个整体的事务来处理除了上面使用事务传递来实现外，还可以利用TransactionScope对象来处理，如下：

1. using System.Collections.Generic;
2. using System.Data.Entity;
3. using System.Data.SqlClient;
4. using System.Linq;
5. using System.Transactions;
7. namespace TransactionsExamples
8. {
9. class TransactionsExample
10. {
11. static void UsingTransactionScope()
12. {
13. using (var scope = new TransactionScope(TransactionScopeOption.Required))
14. {
15. using (var conn = new SqlConnection("..."))
16. {
17. conn.Open();
19. var sqlCommand = new SqlCommand();
20. sqlCommand.Connection = conn;
21. sqlCommand.CommandText =
22. @"UPDATE Blogs SET Rating = 5" +
23. " WHERE Name LIKE '%Entity Framework%'";
24. sqlCommand.ExecuteNonQuery();
26. using (var context =
27. new BloggingContext(conn, contextOwnsConnection: false))
28. {
29. var query = context.Posts.Where(p => p.Blog.Rating > 5);
30. foreach (var post in query)
31. {
32. post.Title += "[Cool Blog]";
33. }
34. context.SaveChanges();
35. }
36. }
38. scope.Complete();
39. }
40. }
41. }
42. }

注意：上面提交事务是通过TransactionScope实例的Complete方法来提交的。

可以看到使用TransactionScope使我们代码简化了不少，但是要注意的是TransactionScope也有一些限制：

1、需要NET 4.5.1及以上

2、不能和Database.UseTransaction()方式结合起来使用

3、sql语句中不能有DLL操作

4、不能在云场景中使用，除非你保证只有一个数据库连接。（支场景中不支持分布式事务）