.NET可逆框架设计

　2012-06-25 07:26:47　来源：WEB开发网　　　

核心提示：2.2可逆框架的入口实现我们需要简单的调用就能方便的使用可逆功能，不能以一种新的方式使用，.NET可逆框架设计(3)，所以这里借鉴了Transaction Scope的设计思想，请看代码： /*** * author:深度训练 * blog:http://wangqingpei557.bl

2.2可逆框架的入口实现

我们需要简单的调用就能方便的使用可逆功能，不能以一种新的方式使用。所以这里借鉴了Transaction Scope的设计思想。

请看代码：

/***
* author:深度训练
* blog:http://wangqingpei557.blog.51cto.com/
* **/
using System;
using System.Collections.Generic;
using System.Text;
using System.Transactions;
namespace ReversibleLib
{
　　/// <summary>
　　/// 使代码成为可逆框架的事务性代码
　　/// </summary>
　　public class ReversibleManagerScope : IDisposable
　　{
　　　　/// <summary>
　　　　/// 初始化ReversibleManagerScope新的实例
　　　　/// </summary>
　　　　public ReversibleManagerScope()
　　　　{
　　　　　　ReversibleManager._reversibleManager = new ReversibleManager();
　　　　}
　　　　/// <summary>
　　　　/// 使用ReversibleManager对象构造ReversibleManagerScope使用范围对象
　　　　/// </summary>
　　　　/// <param name="manager">ReversibleManager实例</param>
　　　　public ReversibleManagerScope(ReversibleManager manager)
　　　　{
　　　　　　ReversibleManager._reversibleManager = manager;
　　　　}
　　　　/// <summary>
　　　　/// 使用自定义资源管理器构造ReversibleManagerScope包装的环境ReversibleManager.Current中的对象实例。
　　　　/// </summary>
　　　　/// <param name="source">IEnlistmentNotification资源管理器</param>
　　　　public ReversibleManagerScope(IEnlistmentNotification source)
　　　　{
　　　　　　ReversibleManager._reversibleManager = new ReversibleManager(source);
　　　　}
　　　　/// <summary>
　　　　/// 全局上下文ReversibleManager对象销毁
　　　　/// </summary>
　　　　public void Dispose()
　　　　{
　　　　　　ReversibleManager._reversibleManager = null;
　　　　}
　　　　/// <summary>
　　　　/// 完成整个操作的提交。该操作将提交事务栈中的所有依赖事务
　　　　/// </summary>
　　　　public void Completed()
　　　　{
　　　　　　ReversibleManager.Current.Commit();
　　　　}
　　}
　　/// <summary>
　　/// 可逆模块的入口。
　　/// ReversibleManager对事务对象的封装，实现阶段性的事务提交和回滚。
　　/// </summary>
　　public class ReversibleManager
　　{
　　　　#region 上下文静态ReversibleManager实例
　　　　/// <summary>
　　　　/// 持有对可逆框架的对象引用
　　　　/// </summary>
　　　　internal static ReversibleManager _reversibleManager;
　　　　/// <summary>
　　　　/// 获取当前上下文中可逆框架
　　　　/// </summary>
　　　　public static ReversibleManager Current
　　　　{
　　　　　　get { return _reversibleManager; }
　　　　}
　　　　#endregion
　　　　#region 构造对象
　　　　/// <summary>
　　　　/// 默认构造函数
　　　　/// </summary>
　　　　public ReversibleManager() { }
　　　　/// <summary>
　　　　/// 表示可提交的事务(主事务)
　　　　/// </summary>
　　　　private CommittableTransaction _commiTransaction;
　　　　/// <summary>
　　　　/// 支持两阶段提交协议的资源管理器(主资源管理器)
　　　　/// </summary>
　　　　private IEnlistmentNotification _resourceManager;
　　　　/// <summary>
　　　　/// 重载构造函数，使用自定义资源管理器构造可逆模块的开始。
　　　　/// </summary>
　　　　/// <param name="resource">IEnlistmentNotification接口对象</param>
　　　　public ReversibleManager(IEnlistmentNotification resource)
　　　　{
　　　　　　_resourceManager = resource;
　　　　　　InitLoad(IsolationLevel.Serializable);
　　　　}
　　　　/// <summary>
　　　　/// 重载构造函数，使用自定义资源管理器、内部事务范围的事务隔离级别构造可逆模型的开始。
　　　　/// </summary>
　　　　/// <param name="resource">IEnlistmentNotification接口对象</param>
　　　　/// <param name="isolationlevel">IsolationLevel枚举成员</param>
　　　　public ReversibleManager(IEnlistmentNotification resource, IsolationLevel isolationlevel)
　　　　{
　　　　　　_resourceManager = resource;
　　　　　　InitLoad(isolationlevel);
　　　　}
　　　　/// <summary>
　　　　/// 事务初始化阶段的参数对象
　　　　/// </summary>
　　　　TransactionOptions _options;
　　　　/// <summary>
　　　　/// 重载构造函数，使用自定义资源管理器、内部事务范围的事务隔离级别、事务超时时间范围构造可逆模块的开始。
　　　　/// </summary>
　　　　/// <param name="resource">IEnlistmentNotification接口对象</param>
　　　　/// <param name="isolationlevel">IsolationLevel枚举成员</param>
　　　　/// <param name="span">TimeSpan时间范围</param>
　　　　public ReversibleManager(IEnlistmentNotification resource, IsolationLevel isolationlevel, TimeSpan span)
　　　　{
　　　　　　_options = new TransactionOptions();
　　　　　　_options.Timeout = span;
　　　　　　InitLoad(isolationlevel);
　　　　}
　　　　/// <summary>
　　　　/// 构造CommittableTransaction对象实例。
　　　　/// </summary>
　　　　/// <param name="level">事务隔离级别</param>
　　　　private void InitLoad(IsolationLevel level)
　　　　{
　　　　　　if (_options == null)
　　　　　　　　_options = new TransactionOptions();
　　　　　　_options.IsolationLevel = level;
　　　　　　_commiTransaction = new CommittableTransaction(_options);
　　　　　　_commiTransaction.EnlistVolatile(_resourceManager, EnlistmentOptions.None);
　　　　　　//作为事务栈的头开始整个可逆结构。
　　　　　　_tranStack.Push(_commiTransaction);//压入事务栈
　　　　　　_resourceStack.Push(_resourceManager);//压入资源栈
　　　　　　//设置环境事务，让所有支持事务性感知框架的代码都能执行。
　　　　　　Transaction.Current = _commiTransaction;
　　　　}
　　　　#endregion
　　　　/// <summary>
　　　　/// 事务栈，依次存放事务。
　　　　/// </summary>
　　　　private System.Collections.Generic.Stack<Transaction> _tranStack = new Stack<Transaction>();
　　　　/// <summary>
　　　　/// 资源栈，依次存放事务使用的资源。
　　　　/// </summary>
　　　　private System.Collections.Generic.Stack<IEnlistmentNotification> _resourceStack = new Stack<IEnlistmentNotification>();
　　　　/// <summary>
　　　　/// 阶段性事件委托
　　　　/// </summary>
　　　　/// <param name="tran">Transaction环境事务</param>
　　　　public delegate void PhaseHanlder(System.Transactions.Transaction tran);
　　　　/// <summary>
　　　　/// 下一步事件
　　　　/// </summary>
　　　　public event PhaseHanlder NextEvent;
　　　　/// <summary>
　　　　/// 上一步事件
　　　　/// </summary>
　　　　public event PhaseHanlder PreviousEvent;
　　　　/// <summary>
　　　　/// 开始下一步操作
　　　　/// </summary>
　　　　/// <typeparam name="S">IEnlistmentNotification接口实现</typeparam>
　　　　/// <param name="level">IsolationLevel事务的隔离级别(对全局事务处理设置)</param>
　　　　/// <param name="source">下一步操作的自定义数据管理器</param>
　　　　public void Next<S>(IsolationLevel level, S source)
　　　　　　where S : class,IEnlistmentNotification, new()
　　　　{
　　　　　　Transaction tran = _tranStack.Peek();//获取事务栈的顶端事务
　　　　　　if (tran == null)
　　　　　　　　tran = Transaction.Current;//主事务
　　　　　　DependentTransaction depentran = tran.DependentClone(DependentCloneOption.BlockCommitUntilComplete);
　　　　　　//将本次事务处理的资源管理器压入资源栈中
　　　　　　depentran.EnlistVolatile(source, EnlistmentOptions.None);
　　　　　　_tranStack.Push(depentran);
　　　　　　_resourceStack.Push(source);
　　　　　　//切换环境事务场景
　　　　　　Transaction.Current = depentran;
　　　　　　if (NextEvent != null)
　　　　　　　　if (NextEvent.GetInvocationList().Length > 0)
　　　　　　　　　　NextEvent(Transaction.Current);
　　　　}
　　　　/// <summary>
　　　　/// 返回上一步操作
　　　　/// </summary>
　　　　/// <typeparam name="T">需要接受的数据对象类型</typeparam>
　　　　/// <param name="refadd">需要接受的数据对象引用</param>
　　　　public void Previous<T>(out T refadd) where T : class,new()
　　　　{
　　　　　　Transaction tran = _tranStack.Pop();
　　　　　　if (tran == null)//顶层事务
　　　　　　　　Transaction.Current.Rollback();
　　　　　　// tran.Rollback();//回滚本事务,将触发所有克隆事务的回滚。
　　　　　　if (PreviousEvent != null)
　　　　　　　　if (PreviousEvent.GetInvocationList().Length > 0)
　　　　　　　　{
　　　　　　　　　　//设置上一步数据对象
　　　　　　　　　　refadd = (_resourceStack.Pop() as IReversibleGetResourceData<T>).GetPreviousData();
　　　　　　　　　　PreviousEvent(Transaction.Current);
　　　　　　　　　　return;
　　　　　　　　}
　　　　　　refadd = new T();//事务处理异常
　　　　}
　　　　/// <summary>
　　　　/// 提交事物堆栈中的所有事物
　　　　/// </summary>
　　　　public void Commit()
　　　　{
　　　　　　if (Transaction.Current is DependentTransaction)
　　　　　　　　(Transaction.Current as DependentTransaction).Complete();
　　　　　　for (int i = 0; i < _tranStack.Count - 1; i++)
　　　　　　{
　　　　　　　　//依赖事务
　　　　　　　　(_tranStack.Pop() as DependentTransaction).Complete();
　　　　　　}
　　　　　　//提交事务，主事务。必须进行克隆主体的提交才能完成所有阶段的操作。
　　　　　　(_tranStack.Pop() as CommittableTransaction).Commit();
　　　　}
　　　　/// <summary>
　　　　/// 回滚事物堆栈中的所有事物
　　　　/// </summary>
　　　　public void RollBack()
　　　　{
　　　　　　if (Transaction.Current is DependentTransaction)
　　　　　　　　(Transaction.Current as DependentTransaction).Rollback();
　　　　　　for (int i = 0; i < _tranStack.Count - 1; i++)
　　　　　　{
　　　　　　　　//依赖事务
　　　　　　　　(_tranStack.Pop() as DependentTransaction).Rollback();
　　　　　　}
　　　　　　//提交事务，主事务。必须进行克隆主体的提交才能完成所有阶段的操作。
　　　　　　(_tranStack.Pop() as CommittableTransaction).Rollback();
　　　　}
　　}
}