把事务封装成类似Serializable用法的特性

  最近几天上班没事可做就想着整理常用的类库方法，验证、消息、分页、模版引擎、数据库操作、ini操作、文本操作、xml操作等，最后就是现在这个事务特性。

   

 /// <summary>
    /// 事务形象属性的接口
    /// </summary>
    internal class TransactionAspectProperty : IContextProperty, IContributeObjectSink
    {
        //冻结策略
        public void Freeze(Context newContext)
        {
        }
        //获取事务接口容器
        public IMessageSink GetObjectSink(MarshalByRefObject obj, IMessageSink nextSink)
        {
            return new TransactionAspect((BaseBusinessComponent) obj, nextSink);
        }
        //判断是否存在策略
        public bool IsNewContextOK(Context newCtx)
        {
            return true;
        }
        //获取特性名称
        public string Name
        {
            get
            {
                return "TransactionAspectProperty";
            }
        }
        //获取Remoting特性名称
          string System.Runtime.Remoting.Contexts.IContextProperty.Name
        {
            get
            {
                return "TransactionAspectProperty";
            }
        }
    }

Freeze、IsNewContextOK、Name是IContextProperty 成员 GetObjectSink是IContributeObjectSink 成员

TransactionAspectProperty继承于IContextProperty、IContributeObjectSink，用于返回权限验证消息接收器的实例TransactionAspect

 //事务的特性
    internal sealed class TransactionAspectAttribute : ContextAttribute
    {
        public TransactionAspectAttribute() : base("TransactionAspect")
        {
        }
        /// <summary>
        /// 从写父类的特性
        /// </summary>
        /// <param name="ccm"></param>
        public override void GetPropertiesForNewContext(IConstructionCallMessage ccm)
        {
            if (ccm != null)
            {
                ccm.ContextProperties.Add(new TransactionAspectProperty());
            }
        }
    }

TransactionAspectAttribute继承ContextAttribute的特性

 internal class TransactionAspect : IMessageSink
    {
        private BaseBusinessComponent _biz;//抽象类
        private IMessageSink _nextSink;//消息管理

        public TransactionAspect(BaseBusinessComponent biz, IMessageSink nextSink)
        {
            this._biz = biz;
            this._nextSink = nextSink;
        }
    
           
        /// <summary>
        ///  异步处理给定的消息。
        /// </summary>
        /// <param name="msg">要处理的消息。</param>
        /// <param name="replySink"> 答复消息的答复接收器。</param>
        /// <returns>返回 System.Runtime.Remoting.Messaging.IMessageCtrl 接口，该接口提供一种在调度异步消息之后控制这些消息的方法。</returns>
        public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
        {
            return null;
        }
        /// <summary>
        /// 检查是否存在事务
        /// </summary>
        /// <param name="m"></param>
        /// <returns></returns>
        private static bool ExistsEnableCommit(MethodBase m)
        {
            object[] attributes = m.GetCustomAttributes(true);
            object[] VB_t_array_L0 = attributes;
            for (int VB_t_i4_L0 = 0; VB_t_i4_L0 < VB_t_array_L0.Length; VB_t_i4_L0++)
            {
                if (RuntimeHelpers.GetObjectValue(VB_t_array_L0[VB_t_i4_L0]) is EnableCommitAttribute)
                {
                    return true;
                }
            }
            return false;
        }
        /// <summary>
        /// 消息管理接口
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        public IMessage SyncProcessMessage(IMessage msg)
        {
            IMessage returnMessage;//通信信息
            IMethodMessage methodMesssage = (IMethodMessage) msg;//方法的消息
            this._biz.Rollback = false;
            if (ExistsEnableCommit(methodMesssage.MethodBase))//判断是否授权的事务
            {
                TimeSpan VB_t_struct_S0 = new TimeSpan(0L);//间隔
                using (TransactionScope scope = new TransactionScope(TransactionScopeOption.RequiresNew, VB_t_struct_S0))//事务模式
                {
                    returnMessage = this._nextSink.SyncProcessMessage(msg);
                    Exception resultCommitException = ((IMethodReturnMessage) returnMessage).Exception;//错误信息
                    if (resultCommitException != null)
                    {
                        throw resultCommitException;
                    }
                    if (!this._biz.Rollback)
                    {
                        scope.Complete();//提交事务
                    }
                }
                return returnMessage;
            }
            returnMessage = this._nextSink.SyncProcessMessage(msg);//返回同步消息
            Exception resultException = ((IMethodReturnMessage) returnMessage).Exception;//错误的信息
            if (resultException != null)
            {
                throw resultException;
            }
            return returnMessage;
        }
        /// <summary>
        /// 获取接收器链中的下一个消息接收器。
        /// </summary>
        public IMessageSink NextSink
        {
            get
            {
                return this._nextSink;
            }
        }
        //System.Runtime.Remoting.Messaging.IMessageSink.NextSink
         IMessageSink System.Runtime.Remoting.Messaging.IMessageSink.NextSink
        {
            get
            {
                return this._nextSink;
            }
        }
    }

TransactionAspect继承IMessageSink处理事务消息这个是关键部分 。于通过反射取得业务层方法上所有的验证权限属性EnableCommitAttribute，并逐个进行验证。

 [TransactionAspect]//定义事务提交的抽象类
    public abstract class BaseBusinessComponent : ContextBoundObject
    {
        private bool _rollback;

        protected BaseBusinessComponent()
        {
        }
        //执行的状态 是否回滚
        public bool Rollback
        {
            get
            {
                return this._rollback;
            }
            set
            {
                this._rollback = value;
            }
        }
    }

定义BaseBusinessComponent抽象类 ，用于具体实现的业务类继承实现

 [AttributeUsage(AttributeTargets.Method)]
    public sealed class EnableCommitAttribute : Attribute
    {
    }

EnableCommitAttribute继承Attribute特性，验证调用方法所需要的权限，具体的验证规则与用户信息由继承类编写。

调用处：

namespace demo
{
    public class hous : BaseBusinessComponent//继承这个抽象基类
    {

        [EnableCommit]//加上这个就启动事务特性
        public bool add(string w)
        {
            
            bool bl = false;
            //过滤器
            
            //业务逻辑部分省略

            if (bl)
            {
                this.Rollback = true;//表示不提交事务，回滚
                return false;
            }

            return true;
           
        }
     
    }
}

到此就实现了 类似 web.Match 与 Serializable 一样的特性用法只要在普通方法上加上 [EnableCommit]就实现了事务 不要事务去除即可，讲的不好请见谅。