Workflow之打造RetryActivity

1、前言

    .net Framework 3.0的Workflow用过了吧，什么？还没有，好吧，就连我这种当初认为Workflow是个不值得花时间去学习的人也用了一下，毕竟在某些情况下，使用WF的编码效率以及灵活性远要比不使用WF的要高。

2、场景

    比如说，现在需要做个异步的服务，其中有调用了很多其他服务，并且这些服务是远程的，也就是可能在很多阶段都回出现调用失败的情况，当然，由于服务本身是异步的，那么不太可能遇到一个失败就把这个过程都设为失败，要是这样的话，如果每个服务的失败概率是5%，如果过程中有10个这样的服务，那么总体的失败率就达到了40%，显然这个失败率是无法接受的。

    如果按照传统的手段实现重试操作，那么，需要把每一步都记录到数据库或消息队列中，这样在每一步都需要自己写持久化和再次加载的方法，如果对象类型较少，那也不算麻烦，如果对象多了，那就有点吃不消了。

    这里就可以让Workflow大显身手了，在Workflow里面，只需要放一个While、一个IfElse和一个Delay，以及需要Retry的活动本身，再准备一个持久化服务，一个带有Retry功能的服务就自动完成了。

    太抽象了？看图：

    其中的codeActivitiy1部分就是那些可能失败的操作，然后只要设置好While和IfElse的条件，以及延迟的时间，那么这个自动重试就可以工作了。

    只要WF中的持久化服务能工作，那么这个过程中无论Delay多少时间，都不用担心内存问题，也不用担心怎么持久化中间的对象，需要确保的仅仅是这些状态是可以序列化的。

3、更好的方案

    上面的方案看起来不错吧，不过要真正用起来，就会发现太麻烦，只要有一个需要Retry的活动，就需要把这个结构再画一把，画上10个保证想劈了显示器。

    为了避免重复拖拽出这个相似的结构，就自己写一个RetryActivity吧，在从零开始写这个活动的时候，建议参考WhileActivity和DelayActivity的实现，当然，也可以比较偷懒的直接copy这里的实现：

    [Designer(typeof(RetryDesigner), typeof(IDesigner))]
    public partial class RetryActivity
        : CompositeActivity, IEventActivity,
        IActivityEventListener<ActivityExecutionStatusChangedEventArgs>,
        IActivityEventListener<QueueEventArgs>
    {

        #region Sub-Classes

        private sealed class TimeoutDurationConverter : TypeConverter
        {

            public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
            {
                return ((sourceType == typeof(string)) || base.CanConvertFrom(context, sourceType));
            }

            public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
            {
                return ((destinationType == typeof(string)) || base.CanConvertTo(context, destinationType));
            }

            public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
            {
                object zero = TimeSpan.Zero;
                string str = value as string;
                if (!string.IsNullOrEmpty(str))
                {
                    try
                    {
                        zero = TimeSpan.Parse(str);
                        if (zero != null)
                        {
                            TimeSpan span = (TimeSpan)zero;
                            if (span.Ticks < 0L)
                            {
                                throw new Exception(string.Format("Error_NegativeValue:{0}", value.ToString()));
                            }
                        }
                    }
                    catch
                    {
                        throw new Exception("InvalidTimespanFormat" + str);
                    }
                }
                return zero;
            }

            public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
            {
                if ((destinationType == typeof(string)) && (value is TimeSpan))
                {
                    TimeSpan span = (TimeSpan)value;
                    return span.ToString();
                }
                return base.ConvertTo(context, culture, value, destinationType);
            }

            public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
            {
                ArrayList values = new ArrayList();
                values.Add(new TimeSpan(0, 0, 0));
                values.Add(new TimeSpan(0, 1, 0));
                values.Add(new TimeSpan(0, 30, 0));
                values.Add(new TimeSpan(1, 0, 0));
                values.Add(new TimeSpan(12, 0, 0));
                values.Add(new TimeSpan(1, 0, 0, 0));
                return new TypeConverter.StandardValuesCollection(values);
            }

            public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
            {
                return true;
            }

        }

        #endregion

        #region Ctors

        public RetryActivity() { }

        public RetryActivity(string name)
            : base(name) { }

        #endregion

        #region Properties

        public static readonly DependencyProperty RetryConditionProperty =
            DependencyProperty.Register("RetryCondition",
            typeof(ActivityCondition), typeof(RetryActivity),
            new PropertyMetadata(DependencyPropertyOptions.Metadata,
                new Attribute[]
                {
                    new ValidationOptionAttribute(ValidationOption.Required)
                }));

        public ActivityCondition RetryCondition
        {
            get
            {
                return (base.GetValue(RetryConditionProperty) as ActivityCondition);
            }
            set
            {
                base.SetValue(RetryConditionProperty, value);
            }
        }

        public static readonly DependencyProperty IsInEventActivityModeProperty =
            DependencyProperty.Register("IsInEventActivityMode",
            typeof(bool), typeof(RetryActivity), new PropertyMetadata(false));

        private bool IsInEventActivityMode
        {
            get { return (bool)base.GetValue(IsInEventActivityModeProperty); }
            set { base.SetValue(IsInEventActivityModeProperty, value); }
        }

        public static readonly DependencyProperty InitializeTimeoutDurationEvent =
            DependencyProperty.Register("InitializeTimeoutDuration",
            typeof(EventHandler), typeof(RetryActivity));

        [MergableProperty(false), Category("Handlers"), Description("TimeoutInitializerDescription")]
        public event EventHandler InitializeTimeoutDuration
        {
            add { base.AddHandler(InitializeTimeoutDurationEvent, value); }
            remove { base.RemoveHandler(InitializeTimeoutDurationEvent, value); }
        }

        public static readonly DependencyProperty TimeoutDurationProperty =
            DependencyProperty.Register("TimeoutDuration",
            typeof(TimeSpan), typeof(RetryActivity),
            new PropertyMetadata(new TimeSpan(0, 0, 0)));

        [TypeConverter(typeof(TimeoutDurationConverter)), Description("TimeoutDurationDescription"), MergableProperty(false)]
        public TimeSpan TimeoutDuration
        {
            get { return (TimeSpan)base.GetValue(TimeoutDurationProperty); }
            set { base.SetValue(TimeoutDurationProperty, value); }
        }

        public static readonly DependencyProperty QueueNameProperty =
            DependencyProperty.Register("QueueName",
            typeof(IComparable), typeof(RetryActivity));

        public static readonly DependencyProperty SubscriptionIDProperty =
            DependencyProperty.Register("SubscriptionID",
            typeof(Guid), typeof(RetryActivity),
            new PropertyMetadata(Guid.NewGuid()));

        private Guid SubscriptionID
        {
            get { return (Guid)base.GetValue(SubscriptionIDProperty); }
            set { base.SetValue(SubscriptionIDProperty, value); }
        }

        #endregion

        #region Overrides

        protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext)
        {
            if (executionContext == null)
                throw new ArgumentNullException("executionContext");
            if (base.EnabledActivities.Count == 0)
                return ActivityExecutionStatus.Closed;
            Activity activity = base.EnabledActivities[0];
            if (!this.IsInEventActivityMode && (this.SubscriptionID != Guid.Empty))
                ((IEventActivity)this).Unsubscribe(executionContext, this);
            ActivityExecutionContext context = executionContext.ExecutionContextManager.GetExecutionContext(activity);
            if (context == null)
                return ActivityExecutionStatus.Closed;
            if (context.Activity.ExecutionStatus == ActivityExecutionStatus.Executing)
                context.CancelActivity(context.Activity);
            return ActivityExecutionStatus.Canceling;
        }

        protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
        {
            if (executionContext == null)
                throw new ArgumentNullException("executionContext");
            if (this.ExecuteCore(executionContext))
                return ActivityExecutionStatus.Executing;
            else
                return ActivityExecutionStatus.Closed;
        }

        protected override void Initialize(IServiceProvider provider)
        {
            base.Initialize(provider);
            base.SetValue(IsInEventActivityModeProperty, true);
        }

        protected override void OnClosed(IServiceProvider provider)
        {
            base.RemoveProperty(SubscriptionIDProperty);
            base.RemoveProperty(IsInEventActivityModeProperty);
        }

        protected sealed override ActivityExecutionStatus HandleFault(ActivityExecutionContext executionContext, Exception exception)
        {
            if (executionContext == null)
                throw new ArgumentNullException("executionContext");
            if (exception == null)
                throw new ArgumentNullException("exception");
            ActivityExecutionStatus status = this.Cancel(executionContext);
            if (status == ActivityExecutionStatus.Canceling)
                return ActivityExecutionStatus.Faulting;
            else
                return status;
        }

        #endregion

        #region Private Implements

        private bool ExecuteCore(ActivityExecutionContext context)
        {
            this.IsInEventActivityMode = false;
            if (base.ExecutionStatus == ActivityExecutionStatus.Canceling ||
                base.ExecutionStatus == ActivityExecutionStatus.Faulting)
                return false;
            if (base.EnabledActivities.Count > 0)
            {
                ActivityExecutionContext context2 = context.ExecutionContextManager.CreateExecutionContext(base.EnabledActivities[0]);
                context2.Activity.RegisterForStatusChange(Activity.ClosedEvent, this);
                context2.ExecuteActivity(context2.Activity);
            }
            return true;
        }

        private TimerEventSubscriptionCollection SubscriptionCollection
        {
            get
            {
                Activity parent = this;
                while (parent.Parent != null)
                    parent = parent.Parent;
                return (TimerEventSubscriptionCollection)parent.GetValue(TimerEventSubscriptionCollection.TimerCollectionProperty);
            }
        }

        #endregion

        #region IEventActivity Members

        IComparable IEventActivity.QueueName
        {
            get { return (IComparable)base.GetValue(QueueNameProperty); }
        }

        void IEventActivity.Subscribe(ActivityExecutionContext parentContext,
            IActivityEventListener<QueueEventArgs> parentEventHandler)
        {
            if (parentContext == null)
                throw new ArgumentNullException("parentContext");
            if (parentEventHandler == null)
                throw new ArgumentNullException("parentEventHandler");
            this.IsInEventActivityMode = true;
            base.RaiseEvent(InitializeTimeoutDurationEvent, this, EventArgs.Empty);
            TimeSpan timeoutDuration = this.TimeoutDuration;
            DateTime expiresAt = DateTime.UtcNow + timeoutDuration;
            Guid guid = Guid.NewGuid();
            base.SetValue(QueueNameProperty, guid);
            WorkflowQueuingService service = parentContext.GetService<WorkflowQueuingService>();
            IComparable queueName = guid;
            TimerEventSubscription item = new TimerEventSubscription(guid, base.WorkflowInstanceId, expiresAt);
            service.CreateWorkflowQueue(queueName, false).RegisterForQueueItemAvailable(parentEventHandler, base.QualifiedName);
            this.SubscriptionID = item.SubscriptionId;
            SubscriptionCollection.Add(item);
        }

        void IEventActivity.Unsubscribe(ActivityExecutionContext parentContext,
            IActivityEventListener<QueueEventArgs> parentEventHandler)
        {
            if (parentContext == null)
                throw new ArgumentNullException("parentContext");
            if (parentEventHandler == null)
                throw new ArgumentNullException("parentEventHandler");
            WorkflowQueuingService service = parentContext.GetService<WorkflowQueuingService>();
            WorkflowQueue workflowQueue = null;
            try
            {
                workflowQueue = service.GetWorkflowQueue(this.SubscriptionID);
            }
            catch { }
            if ((workflowQueue != null) && (workflowQueue.Count != 0))
                workflowQueue.Dequeue();
            SubscriptionCollection.Remove(this.SubscriptionID);
            if (workflowQueue != null)
            {
                workflowQueue.UnregisterForQueueItemAvailable(parentEventHandler);
                service.DeleteWorkflowQueue(this.SubscriptionID);
            }
            this.SubscriptionID = Guid.Empty;
        }

        #endregion

        #region IActivityEventListener<ActivityExecutionStatusChangedEventArgs> Members

        void IActivityEventListener<ActivityExecutionStatusChangedEventArgs>.OnEvent(
            object sender, ActivityExecutionStatusChangedEventArgs e)
        {
            if (e == null)
                throw new ArgumentNullException("e");
            if (sender == null)
                throw new ArgumentNullException("sender");
            ActivityExecutionContext context = sender as ActivityExecutionContext;
            if (context == null)
                throw new ArgumentException("Error_SenderMustBeActivityExecutionContext", "sender");
            e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this);
            ActivityExecutionContextManager executionContextManager = context.ExecutionContextManager;
            executionContextManager.CompleteExecutionContext(executionContextManager.GetExecutionContext(e.Activity));
            bool retry = this.RetryCondition.Evaluate(this, context);
            if (retry)
                ((IEventActivity)this).Subscribe(context, this);
            else
                context.CloseActivity();
        }

        #endregion

        #region IActivityEventListener<QueueEventArgs> Members

        void IActivityEventListener<QueueEventArgs>.OnEvent(object sender, QueueEventArgs e)
        {
            if (sender == null)
                throw new ArgumentNullException("sender");
            if (e == null)
                throw new ArgumentNullException("e");
            ActivityExecutionContext context = sender as ActivityExecutionContext;
            if (context == null)
                throw new ArgumentException("Error_SenderMustBeActivityExecutionContext", "sender");
            if (base.ExecutionStatus != ActivityExecutionStatus.Closed)
            {
                WorkflowQueuingService service = context.GetService<WorkflowQueuingService>();
                service.GetWorkflowQueue(e.QueueName).Dequeue();
                service.DeleteWorkflowQueue(e.QueueName);
                ExecuteCore(context);
            }
        }

        #endregion

    }

    是不是感觉很长，其实就是把While和Delay两者的代码合并到了一起。

    顺便借用一下While的Designer，给它改个名字，换成RetryDesigner：

    [ActivityDesignerTheme(typeof(RetryDesignerTheme))]
    internal sealed class RetryDesigner : SequentialActivityDesigner
    {

        public override bool CanInsertActivities(HitTestInfo insertLocation, ReadOnlyCollection<Activity> activitiesToInsert)
        {
            if ((this == base.ActiveView.AssociatedDesigner) && (this.ContainedDesigners.Count > 0))
            {
                return false;
            }
            return base.CanInsertActivities(insertLocation, activitiesToInsert);
        }

        protected override Rectangle[] GetConnectors()
        {
            Rectangle[] connectors = base.GetConnectors();
            CompositeDesignerTheme designerTheme = base.DesignerTheme as CompositeDesignerTheme;
            if (this.Expanded && (connectors.GetLength(0) > 0))
            {
                connectors[connectors.GetLength(0) - 1].Height -= ((designerTheme != null) ? designerTheme.ConnectorSize.Height : 0) / 3;
            }
            return connectors;
        }

        protected override void Initialize(Activity activity)
        {
            base.Initialize(activity);
            this.HelpText = "DropActivityHere";
        }

        protected override Size OnLayoutSize(ActivityDesignerLayoutEventArgs e)
        {
            Size size = base.OnLayoutSize(e);
            CompositeDesignerTheme designerTheme = e.DesignerTheme as CompositeDesignerTheme;
            if ((designerTheme != null) && this.Expanded)
            {
                size.Width += 2 * designerTheme.ConnectorSize.Width;
                size.Height += designerTheme.ConnectorSize.Height;
            }
            return size;
        }

        protected override void OnPaint(ActivityDesignerPaintEventArgs e)
        {
            base.OnPaint(e);
            if (this.Expanded)
            {
                CompositeDesignerTheme designerTheme = e.DesignerTheme as CompositeDesignerTheme;
                if (designerTheme != null)
                {
                    Rectangle bounds = base.Bounds;
                    Rectangle textRectangle = this.TextRectangle;
                    Rectangle imageRectangle = this.ImageRectangle;
                    Point empty = Point.Empty;
                    if (!imageRectangle.IsEmpty)
                    {
                        empty = new Point(imageRectangle.Right + (e.AmbientTheme.Margin.Width / 2), imageRectangle.Top + (imageRectangle.Height / 2));
                    }
                    else if (!textRectangle.IsEmpty)
                    {
                        empty = new Point(textRectangle.Right + (e.AmbientTheme.Margin.Width / 2), textRectangle.Top + (textRectangle.Height / 2));
                    }
                    else
                    {
                        empty = new Point((bounds.Left + (bounds.Width / 2)) + (e.AmbientTheme.Margin.Width / 2), bounds.Top + (e.AmbientTheme.Margin.Height / 2));
                    }
                    Point[] points = new Point[4];
                    points[0].X = bounds.Left + (bounds.Width / 2);
                    points[0].Y = bounds.Bottom - (designerTheme.ConnectorSize.Height / 3);
                    points[1].X = bounds.Right - (designerTheme.ConnectorSize.Width / 3);
                    points[1].Y = bounds.Bottom - (designerTheme.ConnectorSize.Height / 3);
                    points[2].X = bounds.Right - (designerTheme.ConnectorSize.Width / 3);
                    points[2].Y = empty.Y;
                    points[3].X = empty.X;
                    points[3].Y = empty.Y;
                    base.DrawConnectors(e.Graphics, designerTheme.ForegroundPen, points, LineAnchor.None, LineAnchor.ArrowAnchor);
                    Point[] pointArray2 = new Point[] { points[0], new Point(bounds.Left + (bounds.Width / 2), bounds.Bottom) };
                    base.DrawConnectors(e.Graphics, designerTheme.ForegroundPen, pointArray2, LineAnchor.None, LineAnchor.None);
                }
            }
        }

    }

    以及While的Theme，也改个名字：

    internal sealed class RetryDesignerTheme : CompositeDesignerTheme
    {
        public RetryDesignerTheme(WorkflowTheme theme)
            : base(theme)
        {
            this.ShowDropShadow = false;
            this.ConnectorStartCap = LineAnchor.None;
            this.ConnectorEndCap = LineAnchor.ArrowAnchor;
            this.ForeColor = Color.FromArgb(0xff, 0x52, 0x8a, 0xf7);
            this.BorderColor = Color.FromArgb(0xff, 0xe0, 0xe0, 0xe0);
            this.BorderStyle = DashStyle.Dash;
            this.BackColorStart = Color.FromArgb(0, 0, 0, 0);
            this.BackColorEnd = Color.FromArgb(0, 0, 0, 0);
        }
    }

    好了，这个RetryActivity以及可以用了。

4、试用RetryActivity

    是不是觉得不可思议，东拼西凑的一个RetryActivity就完成了，感觉就像是在忽悠别人一样。

    好吧，耳听为虚，眼见为实。看看在Designer中的样子：

    以及它的属性：

    其中的codeActivity2代表可能需要重试的活动，RetryCondition则表达一个需要重试的条件，TimeoutDuration（因为Delay里面是这个名字，Copy的时候偷懒了，连名字也没改）则表示需要重试的情况下的延迟时间。

    这个RetryActivity有这么几个优点：

• 拖拽起来简单
• 由于RetryActivity的实现更接近于DoWhile语义，所以不用担心RetryCondition对第一次进入时的判断
• 看起来舒服，至少比一个While+一个IfElse+一个Delay要少很多东西

    不过，同样也有一些部分没有做严格的实现，例如：

• 中间的活动出现Cancel、Fault等状态时没有严格测试过
• 没有自定义验证

    所以，如果遇到问题，最好能告知本人。