int IComparer <PropertyInfo> .Compare(PropertyInfo x, PropertyInfo y)
        {
            int ret = 0;

            int orderX = 0;
            int orderY = 0;

            object[] attrX = x.GetCustomAttributes(typeof(PipelineEventAttribute), true);
            object[] attrY = y.GetCustomAttributes(typeof(PipelineEventAttribute), true);

            if (attrX.Length > 0)
            {
                PipelineEventAttribute attr = (PipelineEventAttribute)attrX[0];
                orderX = attr.Order;
            }

            if (attrY.Length > 0)
            {
                PipelineEventAttribute attr = (PipelineEventAttribute)attrY[0];
                orderY = attr.Order;
            }

            if (orderX < orderY)
            {
                ret = -1;
            }
            else if (orderX > orderY)
            {
                ret = 1;
            }

            return(ret);
        }
示例#2
0
        public void Execute <C>(C context) where C : PipelineContext
        {
            PropertyInfo[] properties = PipelineEvent.GetType().GetProperties();

            List <PropertyInfo> sortedProperties = properties.ToList <PropertyInfo>();

            sortedProperties.Sort(new PropertyComparer());

            System.Transactions.TransactionScopeOption pipelineScopeOption = TransactionRequirement(sortedProperties);

            using (TransactionScope pipelineScope = new TransactionScope(pipelineScopeOption))
            {
                sortedProperties.ForEach(property =>
                {
                    object[] attributes =
                        property.GetCustomAttributes(typeof(PipelineEventAttribute), true);

                    if (attributes.Length > 0)
                    {
                        PipelineEventAttribute attr = (PipelineEventAttribute)attributes[0];

                        System.Transactions.TransactionScopeOption scopeOption =
                            GetTransactionScopeOption(attr.TransactionScopeOption);

                        object value         = property.GetValue(PipelineEvent, null);
                        Action <C> eventProp = (Action <C>)value;

                        if (eventProp != null)
                        {
                            using (TransactionScope eventScope = new TransactionScope(scopeOption))
                            {
                                if (eventProp != null)
                                {
                                    eventProp(context);
                                    if (context.Cancel == true)
                                    {
                                        throw new Exception(property.Name + " failed.");
                                    }
                                }

                                eventScope.Complete();
                            }
                        }
                    }
                });

                pipelineScope.Complete();
            }
        }
示例#3
0
        private System.Transactions.TransactionScopeOption TransactionRequirement(List <PropertyInfo> sortedProperties)
        {
            System.Transactions.TransactionScopeOption pipelineScopeOption = System.Transactions.TransactionScopeOption.Suppress;

            foreach (PropertyInfo property in sortedProperties)
            {
                object[] attributes = property.GetCustomAttributes(typeof(PipelineEventAttribute), true);
                if (attributes.Length > 0)
                {
                    PipelineEventAttribute attr = (PipelineEventAttribute)attributes[0];
                    if (attr.TransactionScopeOption != TransactionScopeOption.Suppress)
                    {
                        pipelineScopeOption = System.Transactions.TransactionScopeOption.Required;
                        break;
                    }
                }
            }

            return(pipelineScopeOption);
        }