Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Workflow.ComponentModel/AuthoringOM/ActivityExecutor.cs

@@ -0,0 +1,238 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Collections;
+using System.Runtime.Serialization;
+using System.Security.Permissions;
+
+namespace System.Workflow.ComponentModel
+{
+    #region ActivityExecutor
+
+    internal abstract class ActivityExecutor
+    {
+        public abstract ActivityExecutionStatus Execute(Activity activity, ActivityExecutionContext executionContext);
+        public abstract ActivityExecutionStatus Cancel(Activity activity, ActivityExecutionContext executionContext);
+        public abstract ActivityExecutionStatus HandleFault(Activity activity, ActivityExecutionContext executionContext, Exception exception);
+        public abstract ActivityExecutionStatus Compensate(Activity activity, ActivityExecutionContext executionContext);
+    }
+
+    internal class ActivityExecutor<T> : ActivityExecutor where T : Activity
+    {
+        #region System.Workflow.ComponentModel.ActivityExecutor Methods
+
+        public sealed override ActivityExecutionStatus Execute(Activity activity, ActivityExecutionContext executionContext)
+        {
+            return this.Execute((T)activity, executionContext);
+        }
+        public sealed override ActivityExecutionStatus Cancel(Activity activity, ActivityExecutionContext executionContext)
+        {
+            return this.Cancel((T)activity, executionContext);
+        }
+        public sealed override ActivityExecutionStatus HandleFault(Activity activity, ActivityExecutionContext executionContext, Exception exception)
+        {
+            return this.HandleFault((T)activity, executionContext, exception);
+        }
+        public sealed override ActivityExecutionStatus Compensate(Activity activity, ActivityExecutionContext executionContext)
+        {
+            return this.Compensate((T)activity, executionContext);
+        }
+        #endregion
+
+        #region ActivityExecutor<T> Members
+        protected virtual ActivityExecutionStatus Execute(T activity, ActivityExecutionContext executionContext)
+        {
+            if (activity == null)
+                throw new ArgumentNullException("activity");
+            if (executionContext == null)
+                throw new ArgumentNullException("executionContext");
+
+            return activity.Execute(executionContext);
+        }
+        protected virtual ActivityExecutionStatus Cancel(T activity, ActivityExecutionContext executionContext)
+        {
+            if (activity == null)
+                throw new ArgumentNullException("activity");
+            if (executionContext == null)
+                throw new ArgumentNullException("executionContext");
+
+            return activity.Cancel(executionContext);
+        }
+        protected virtual ActivityExecutionStatus HandleFault(T activity, ActivityExecutionContext executionContext, Exception exception)
+        {
+            if (activity == null)
+                throw new ArgumentNullException("activity");
+            if (executionContext == null)
+                throw new ArgumentNullException("executionContext");
+
+            return activity.HandleFault(executionContext, exception);
+        }
+        protected virtual ActivityExecutionStatus Compensate(T activity, ActivityExecutionContext executionContext)
+        {
+            if (activity == null)
+                throw new ArgumentNullException("activity");
+            if (executionContext == null)
+                throw new ArgumentNullException("executionContext");
+
+            System.Diagnostics.Debug.Assert(activity is ICompensatableActivity, "should not get Compensate, if activity is not compensatable");
+            return ((ICompensatableActivity)activity).Compensate(executionContext);
+        }
+
+        #endregion ActivityExecutor
+    }
+    #endregion
+
+    #region CompositeActivityExecutor<T>
+    internal class CompositeActivityExecutor<T> : ActivityExecutor<T>, ISupportWorkflowChanges where T : CompositeActivity
+    {
+        //@@undone:mayankm Once all ActivityExecutor is removed this method should not be virtual.
+        void ISupportWorkflowChanges.OnActivityAdded(ActivityExecutionContext executionContext, Activity addedActivity)
+        {
+            if (executionContext == null)
+                throw new ArgumentNullException("executionContext");
+            if (addedActivity == null)
+                throw new ArgumentNullException("addedActivity");
+
+            CompositeActivity compositeActivity = executionContext.Activity as CompositeActivity;
+            if (compositeActivity == null)
+                throw new ArgumentException(SR.Error_InvalidActivityExecutionContext, "executionContext");
+
+            compositeActivity.OnActivityChangeAdd(executionContext, addedActivity);
+        }
+
+        void ISupportWorkflowChanges.OnActivityRemoved(ActivityExecutionContext executionContext, Activity removedActivity)
+        {
+            if (executionContext == null)
+                throw new ArgumentNullException("executionContext");
+            if (removedActivity == null)
+                throw new ArgumentNullException("removedActivity");
+
+            CompositeActivity compositeActivity = executionContext.Activity as CompositeActivity;
+            if (compositeActivity == null)
+                throw new ArgumentException(SR.Error_InvalidActivityExecutionContext, "executionContext");
+
+            compositeActivity.OnActivityChangeRemove(executionContext, removedActivity);
+        }
+
+        void ISupportWorkflowChanges.OnWorkflowChangesCompleted(ActivityExecutionContext executionContext)
+        {
+            if (executionContext == null)
+                throw new ArgumentNullException("executionContext");
+
+            CompositeActivity compositeActivity = executionContext.Activity as CompositeActivity;
+
+            if (compositeActivity == null)
+                throw new ArgumentException(SR.Error_InvalidActivityExecutionContext, "executionContext");
+
+            compositeActivity.OnWorkflowChangesCompleted(executionContext);
+        }
+
+        // Refer Bug 9339 (VB Compilation Failure - Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information.)
+        //An unhandled exception of type 'System.TypeLoadException' occurred
+        // "Signature of the body and declaration in a method implementation do not match"
+        protected override ActivityExecutionStatus Execute(T activity, ActivityExecutionContext executionContext)
+        {
+            return base.Execute(activity, executionContext);
+        }
+
+        protected override ActivityExecutionStatus Cancel(T activity, ActivityExecutionContext executionContext)
+        {
+            return base.Cancel(activity, executionContext);
+        }
+    }
+    #endregion
+
+    #region ActivityExecutors Class
+
+    internal static class ActivityExecutors
+    {
+        private static Hashtable typeToExecutorMapping = new Hashtable();
+        private static Hashtable executors = new Hashtable();
+
+        internal static ActivityExecutor[] GetActivityExecutors(Activity activity)
+        {
+            if (activity == null)
+                throw new ArgumentNullException("activity");
+
+            Type activityType = activity.GetType();
+            ActivityExecutor[] activityExecutors = executors[activityType] as ActivityExecutor[];
+            if (activityExecutors != null)
+                return activityExecutors;
+
+            lock (executors.SyncRoot)
+            {
+                activityExecutors = executors[activityType] as ActivityExecutor[];
+                if (activityExecutors != null)
+                    return activityExecutors;
+
+                object[] activityExecutorsObjects = null;
+                try
+                {
+                    //activityExecutorsObjects = ComponentDispenser.CreateComponents(activityType, typeof(ActivityExecutorAttribute));
+                    activityExecutorsObjects = ComponentDispenser.CreateActivityExecutors(activity);
+                }
+                catch (Exception e)
+                {
+                    throw new InvalidOperationException(SR.GetString(SR.ExecutorCreationFailedErrorMessage, activityType.FullName), e);
+                }
+
+                if (activityExecutorsObjects == null || activityExecutorsObjects.Length == 0)
+                    throw new InvalidOperationException(SR.GetString(SR.ExecutorCreationFailedErrorMessage, activityType.FullName));
+
+                activityExecutors = new ActivityExecutor[activityExecutorsObjects.Length];
+                for (int index = 0; index < activityExecutorsObjects.Length; index++)
+                {
+                    if (!typeToExecutorMapping.Contains(activityExecutorsObjects[index].GetType()))
+                    {
+                        lock (typeToExecutorMapping.SyncRoot)
+                        {
+                            if (!typeToExecutorMapping.Contains(activityExecutorsObjects[index].GetType()))
+                            {
+                                System.Threading.Thread.MemoryBarrier();
+                                typeToExecutorMapping[activityExecutorsObjects[index].GetType()] = activityExecutorsObjects[index];
+                            }
+                        }
+                    }
+                    activityExecutors[index] = (ActivityExecutor)typeToExecutorMapping[activityExecutorsObjects[index].GetType()];
+                }
+
+                System.Threading.Thread.MemoryBarrier();
+                executors[activityType] = activityExecutors;
+            }
+            return activityExecutors;
+        }
+
+        public static ActivityExecutor GetActivityExecutorFromType(Type executorType)
+        {
+            if (executorType == null)
+                throw new ArgumentNullException("executorType");
+            if (!typeof(ActivityExecutor).IsAssignableFrom(executorType))
+                throw new ArgumentException(
+                    SR.GetString(SR.Error_NonActivityExecutor, executorType.FullName), "executorType");
+
+            ActivityExecutor activityExecutor = typeToExecutorMapping[executorType] as ActivityExecutor;
+            if (activityExecutor != null)
+                return activityExecutor;
+
+            lock (typeToExecutorMapping.SyncRoot)
+            {
+                activityExecutor = typeToExecutorMapping[executorType] as ActivityExecutor;
+                if (activityExecutor != null)
+                    return activityExecutor;
+
+                System.Threading.Thread.MemoryBarrier();
+                typeToExecutorMapping[executorType] = Activator.CreateInstance(executorType);
+            }
+            return (ActivityExecutor)typeToExecutorMapping[executorType];
+        }
+
+        public static ActivityExecutor GetActivityExecutor(Activity activity)
+        {
+            if (activity == null)
+                throw new ArgumentNullException("activity");
+
+            return GetActivityExecutors(activity)[0];
+        }
+    }
+    #endregion
+}