Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Workflow.Activities/StateMachineSubscription.cs

@@ -0,0 +1,242 @@
+#region Using directives
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Reflection;
+using System.Diagnostics;
+using System.Runtime.Remoting.Messaging;
+using System.Workflow.ComponentModel;
+using System.Workflow.ComponentModel.Design;
+using System.Workflow.Runtime;
+using System.Workflow.Runtime.Hosting;
+
+#endregion Using directives
+
+namespace System.Workflow.Activities
+{
+    #region StateMachineSubscription
+
+    [Serializable]
+    internal abstract class StateMachineSubscription : IActivityEventListener<QueueEventArgs>
+    {
+        #region Member Variables
+
+        private Guid _subscriptionId;
+
+        #endregion Member Variables
+
+        #region Properties
+
+        internal Guid SubscriptionId
+        {
+            get
+            {
+                return _subscriptionId;
+            }
+            set
+            {
+                _subscriptionId = value;
+            }
+        }
+
+        #endregion Properties
+
+        void IActivityEventListener<QueueEventArgs>.OnEvent(object sender, QueueEventArgs e)
+        {
+            ActivityExecutionContext context = sender as ActivityExecutionContext;
+            if (context == null)
+                throw new ArgumentException(SR.Error_SenderMustBeActivityExecutionContext, "sender");
+
+            Enqueue(context);
+        }
+
+        protected abstract void Enqueue(ActivityExecutionContext context);
+        internal abstract void ProcessEvent(ActivityExecutionContext context);
+    }
+
+    #endregion StateMachineSubscription
+
+    #region EventActivitySubscription
+
+    [Serializable]
+    internal class EventActivitySubscription : StateMachineSubscription
+    {
+        #region Member Variables
+
+        private string _eventActivityName = String.Empty;
+        private string _eventDrivenName = String.Empty;
+        private string _stateName = String.Empty;
+        private IComparable _queueName;
+
+        #endregion Member Variables
+
+        #region Properties
+
+        internal string EventActivityName
+        {
+            get
+            {
+                return _eventActivityName;
+            }
+        }
+
+        internal string StateName
+        {
+            get
+            {
+                return _stateName;
+            }
+        }
+
+        internal IComparable QueueName
+        {
+            get
+            {
+                return _queueName;
+            }
+        }
+
+        internal string EventDrivenName
+        {
+            get
+            {
+                return _eventDrivenName;
+            }
+        }
+
+        #endregion Properties
+
+        internal void Subscribe(ActivityExecutionContext context,
+            StateActivity state,
+            IEventActivity eventActivity)
+        {
+            eventActivity.Subscribe(context, this);
+            Activity activity = (Activity)eventActivity;
+            this._queueName = eventActivity.QueueName;
+            this._eventActivityName = activity.QualifiedName;
+            this._stateName = state.QualifiedName;
+            this.SubscriptionId = Guid.NewGuid();
+            EventDrivenActivity eventDriven = StateMachineHelpers.GetParentEventDriven(eventActivity);
+            this._eventDrivenName = eventDriven.QualifiedName;
+        }
+
+        internal void Unsubscribe(ActivityExecutionContext context,
+            IEventActivity eventActivity)
+        {
+            eventActivity.Unsubscribe(context, this);
+        }
+
+        protected override void Enqueue(ActivityExecutionContext context)
+        {
+            StateActivity rootState = StateMachineHelpers.GetRootState((StateActivity)context.Activity);
+            StateMachineExecutionState executionState = StateMachineExecutionState.Get(rootState);
+            executionState.SubscriptionManager.Enqueue(context, this.QueueName);
+        }
+
+        internal override void ProcessEvent(ActivityExecutionContext context)
+        {
+            StateActivity rootState = StateMachineHelpers.GetRootState((StateActivity)context.Activity);
+            StateMachineExecutionState executionState = StateMachineExecutionState.Get(rootState);
+            ExternalEventAction action = new ExternalEventAction(this.StateName, this.EventDrivenName);
+            Debug.Assert(!executionState.HasEnqueuedActions);
+            executionState.EnqueueAction(action);
+            executionState.ProcessActions(context);
+        }
+    }
+
+    #endregion EventActivitySubscription
+
+    #region SetStateSubscription
+
+    [Serializable]
+    internal class SetStateSubscription : StateMachineSubscription
+    {
+        private Guid _instanceId;
+
+        internal SetStateSubscription(Guid instanceId)
+        {
+            this._instanceId = instanceId;
+        }
+
+        internal void CreateQueue(ActivityExecutionContext context)
+        {
+            if (!StateMachineHelpers.IsRootExecutionContext(context))
+            {
+                // we only subscribe to the set state event if
+                // we're at the root level. If this instance is
+                // being called, it is not possible to set the
+                // state from the host side directly
+                return;
+            }
+
+            WorkflowQueuingService workflowQueuingService = context.GetService<WorkflowQueuingService>();
+
+            MessageEventSubscription subscription = new MessageEventSubscription(
+                StateMachineWorkflowActivity.SetStateQueueName,
+                this._instanceId);
+
+            WorkflowQueue workflowQueue = workflowQueuingService.CreateWorkflowQueue(
+                StateMachineWorkflowActivity.SetStateQueueName,
+                true);
+            this.SubscriptionId = subscription.SubscriptionId;
+        }
+
+        internal void DeleteQueue(ActivityExecutionContext context)
+        {
+            if (!StateMachineHelpers.IsRootExecutionContext(context))
+            {
+                // we only subscribe to the set state event if
+                // we're at the root level. If this instance is
+                // being called, it is not possible to set the
+                // state from the host side directly
+                return;
+            }
+
+            WorkflowQueuingService workflowQueuingService = context.GetService<WorkflowQueuingService>();
+            WorkflowQueue workflowQueue = workflowQueuingService.GetWorkflowQueue(StateMachineWorkflowActivity.SetStateQueueName);
+            workflowQueuingService.DeleteWorkflowQueue(StateMachineWorkflowActivity.SetStateQueueName);
+        }
+
+        internal void Subscribe(ActivityExecutionContext context)
+        {
+            WorkflowQueuingService workflowQueuingService = context.GetService<WorkflowQueuingService>();
+            WorkflowQueue workflowQueue = workflowQueuingService.GetWorkflowQueue(StateMachineWorkflowActivity.SetStateQueueName);
+            workflowQueue.RegisterForQueueItemAvailable(this);
+        }
+
+        internal void Unsubscribe(ActivityExecutionContext context)
+        {
+            WorkflowQueuingService workflowQueuingService = context.GetService<WorkflowQueuingService>();
+            WorkflowQueue workflowQueue = workflowQueuingService.GetWorkflowQueue(StateMachineWorkflowActivity.SetStateQueueName);
+            workflowQueue.UnregisterForQueueItemAvailable(this);
+        }
+
+        protected override void Enqueue(ActivityExecutionContext context)
+        {
+            StateActivity rootState = StateMachineHelpers.GetRootState((StateActivity)context.Activity);
+            StateMachineExecutionState executionState = StateMachineExecutionState.Get(rootState);
+            executionState.SubscriptionManager.Enqueue(context, this.SubscriptionId);
+        }
+
+        internal override void ProcessEvent(ActivityExecutionContext context)
+        {
+            WorkflowQueuingService workflowQueuingService = context.GetService<WorkflowQueuingService>();
+            WorkflowQueue workflowQueue = workflowQueuingService.GetWorkflowQueue(StateMachineWorkflowActivity.SetStateQueueName);
+            SetStateEventArgs eventArgs = workflowQueue.Dequeue() as SetStateEventArgs;
+            StateActivity currentState = StateMachineHelpers.GetCurrentState(context);
+            if (currentState == null)
+                throw new InvalidOperationException(SR.GetStateMachineWorkflowMustHaveACurrentState());
+
+            StateActivity rootState = StateMachineHelpers.GetRootState((StateActivity)context.Activity);
+            StateMachineExecutionState executionState = StateMachineExecutionState.Get(rootState);
+            SetStateAction action = new SetStateAction(currentState.QualifiedName, eventArgs.TargetStateName);
+            Debug.Assert(!executionState.HasEnqueuedActions);
+            executionState.EnqueueAction(action);
+            executionState.ProcessActions(context);
+        }
+    }
+
+    #endregion SetStateSubscription
+}