About working with transaction for non-database transactions

In the process of manipulating the database, for data consistency, we can use transaction, either commit all when it succeeds, or have any one operation fail to roll back immediately. Not only in the database, sometimes operating other content, such as the operation of the system files, but also need to consider some of the operation of the combination of a transaction.

Now let's look at an example like this. Now we need to create 3 directory a,b,c on the computer's hard disk, requiring either 3 to be all created successfully, or not to create one. We can think of this as a matter of affairs. If we write our own code to do this, we can write this.

[CSharp]View Plaincopy

2. BOOL Createa = false;
4. BOOL Createb = false;
6. BOOL Createc = false;
10. Try
12. {
14. //The operation here is to create a 3 directory
16. Directory.CreateDirectory ("\\a");
18. Createa = true;
20. Directory.CreateDirectory ("\\b");
22. Createb = true;
24. Directory.CreateDirectory ("\\c");
26. Createc = true;
28. }
30. catch (System.Exception ex)
32. {
34. //Here, when catching an exception, roll back according to the result of the run
36. if (CREATEB)
38. {
40. Directory.delete ("\\b");
42. Directory.delete ("\\a");
44. }
46. if (!createb && createa)
48. {
50. Directory.delete ("\\a");
52. }
54. }

But here we are to roll these 3 operations as a whole, in time it is simple to create a delete folder, we can see the rollback logic in the catch is very complex. As you can imagine, if the 3 steps of a,b,c are more than just creating a directory, and there are some other operations, then the logic of rollback is very complex, and we can consider dividing this one into several small transactions and rolling it back. The code can write this, and here we use the Transactin and Transactioscope classes provided by the framework.

[CSharp]View Plaincopy

2. Class Program
4. {
6. static void Main (string[] args)
8. {
10. //Do not need a try catch here, because scope has already completed this function,
12. //That is, when an exception occurs, it will attempt to jump out of the using code block,
14. //CLR will call each transaction before running an exception outside of the code block, respectively.
16. //roolback method, as long as the logic in rollback you define is not a problem, then all
18. //The actions that have occurred will be safely rolled back.
20. using (var scope = new TransactionScope ())
22. {
24. var A = new Operationa ();
26. Transaction.Current.EnlistVolatile (A, Enlistmentoptions.none);
28. A.dowork ();
32. Operationb B = new Operationb ();
34. Transaction.Current.EnlistVolatile (B, Enlistmentoptions.none);
36. B.dowork ();
38. Scope.complete ();
40. }
42. }
48. }
50. }
54. Class Operationa:ienlistmentnotification
56. {
58. private bool _iscommitsucceed = false;
62. public void Commit (Enlistment enlistment)
64. {
66. Enlistment. Done ();
68. }
72. public void DoWork ()//This is a custom method, not an inheritance ienlistmentnotification
74. {
76. Directory.CreateDirectory ("\\a");
78. //There are some other complex operations on a.
80. _iscommitsucceed = true;
82. }
86. public void InDoubt (Enlistment enlistment)
88. {
90. Enlistment. Done ();
92. }
94. public void Prepare (preparingenlistment preparingenlistment)
96. {
98. Preparingenlistment.prepared ();
100. }
102. public void Rollback (Enlistment enlistment)
104. {
106. //Roll back some of the operations of a, of course, the operation logic here requires you to write.
108. //For example, to see if the creation was successful, or to have some other signal markers,
110. //Tag you decide whether to delete the directory or what other rollback operations.
112. if (_iscommitsucceed)
114. Directory.delete ("\\a");
116. Enlistment. Done ();
118. }
120. }
124. Class Operationb:ienlistmentnotification
126. {
128. private bool _iscommitsucceed = false;
132. public void Commit (Enlistment enlistment)
134. {
136. Enlistment. Done ();
138. }
142. public void DoWork ()
144. {
146. //Here are some of the complex operations on B
148. throw New Exception ("test");
150. //There are still some operation code here, but we are simulating that the B operation throws an exception, so the code here does not execute
152. }
156. public void InDoubt (Enlistment enlistment)
158. {
160. Enlistment. Done ();
162. }
164. public void Prepare (preparingenlistment preparingenlistment)
166. {
168. Preparingenlistment.prepared ();
170. }
172. public void Rollback (Enlistment enlistment)
174. {
176. if (_iscommitsucceed)
178. {
180. //Roll back some of the already existing operations of B.
182. }
184. Enlistment. Done ();
186. }

The mechanism here is that there may be a special operation in the Scope.complete () method that tells the CLR that all operations have been completed successfully and that there is no need to invoke those transaction rollback methods when jumping out of this scope. If the Scope.complete () method is not executed, then the rollback method is called when you jump out of the scope code block. This is generally caused by an exception in the logical operation of a transaction, causing the exception to be thrown out of this code block from this direct throw, without the opportunity to execute the code below. It can be seen that the focus here is to write rollback logic, but relative to the original catch logic, here separate for a number of small logic, relatively easy a lot.

It's just a personal writing logic that uses rollback. When using ienlistmentnotification, someone also writes the business logic to commit. If you want to really understand the mechanism of transaction rollback, it is recommended to understand the implementation mechanism of TransactionScope and transactiond in depth.

About working with transaction for non-database transactions