Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Activities/System/Activities/WorkflowInspectionServices.cs

@@ -0,0 +1,198 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.Activities
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections;
+    using System.Runtime;
+    using System.Activities.Validation;
+
+    public static class WorkflowInspectionServices
+    {
+        public static void CacheMetadata(Activity rootActivity)
+        {
+            CacheMetadata(rootActivity, null);
+        }
+
+        public static void CacheMetadata(Activity rootActivity, LocationReferenceEnvironment hostEnvironment)
+        {
+            if (rootActivity == null)
+            {
+                throw FxTrace.Exception.ArgumentNull("rootActivity");
+            }
+
+            if (rootActivity.HasBeenAssociatedWithAnInstance)
+            {
+                throw FxTrace.Exception.AsError(new InvalidOperationException(SR.RootActivityAlreadyAssociatedWithInstance(rootActivity.DisplayName)));
+            }
+
+            IList<ValidationError> validationErrors = null;
+
+            if (hostEnvironment == null)
+            {
+                hostEnvironment = new ActivityLocationReferenceEnvironment();
+            }
+
+            ActivityUtilities.CacheRootMetadata(rootActivity, hostEnvironment, ProcessActivityTreeOptions.FullCachingOptions, null, ref validationErrors);
+
+            ActivityValidationServices.ThrowIfViolationsExist(validationErrors);
+        }
+
+        public static Activity Resolve(Activity root, string id)
+        {
+            if (root == null)
+            {
+                throw FxTrace.Exception.ArgumentNull("root");
+            }
+
+            if (string.IsNullOrEmpty(id))
+            {
+                throw FxTrace.Exception.ArgumentNullOrEmpty("id");
+            }
+
+            if (!root.IsMetadataCached)
+            {
+                IList<ValidationError> validationErrors = null;
+
+                ActivityUtilities.CacheRootMetadata(root, new ActivityLocationReferenceEnvironment(), ProcessActivityTreeOptions.FullCachingOptions, null, ref validationErrors);
+
+                ActivityValidationServices.ThrowIfViolationsExist(validationErrors);
+            }
+
+            QualifiedId parsedId = QualifiedId.Parse(id);
+
+            Activity result;
+            if (!QualifiedId.TryGetElementFromRoot(root, parsedId, out result))
+            {
+                throw FxTrace.Exception.Argument("id", SR.IdNotFoundInWorkflow(id));
+            }
+
+            return result;
+        }
+
+        public static IEnumerable<Activity> GetActivities(Activity activity)
+        {
+            if (activity == null)
+            {
+                throw FxTrace.Exception.ArgumentNull("activity");
+            }
+
+            if (!activity.IsMetadataCached)
+            {
+                IList<ValidationError> validationErrors = null;
+
+                ActivityUtilities.CacheRootMetadata(activity, new ActivityLocationReferenceEnvironment(), ProcessActivityTreeOptions.FullCachingOptions, null, ref validationErrors);
+
+                ActivityValidationServices.ThrowIfViolationsExist(validationErrors);
+            }
+            
+            int i = 0;
+            for (; i < activity.RuntimeArguments.Count; i++)
+            {
+                RuntimeArgument argument = activity.RuntimeArguments[i];
+
+                if (argument.BoundArgument != null && argument.BoundArgument.Expression != null)
+                {
+                    yield return argument.BoundArgument.Expression;
+                }
+            }
+
+            for (i = 0; i < activity.RuntimeVariables.Count; i++)
+            {
+                Variable variable = activity.RuntimeVariables[i];
+
+                if (variable.Default != null)
+                {
+                    yield return variable.Default;
+                }
+            }
+
+            for (i = 0; i < activity.ImplementationVariables.Count; i++)
+            {
+                Variable variable = activity.ImplementationVariables[i];
+
+                if (variable.Default != null)
+                {
+                    yield return variable.Default;
+                }
+            }
+
+            for (i = 0; i < activity.Children.Count; i++)
+            {
+                yield return activity.Children[i];
+            }
+
+            for (i = 0; i < activity.ImportedChildren.Count; i++)
+            {
+                yield return activity.ImportedChildren[i];
+            }
+
+            for (i = 0; i < activity.ImplementationChildren.Count; i++)
+            {
+                yield return activity.ImplementationChildren[i];
+            }
+
+            for (i = 0; i < activity.Delegates.Count; i++)
+            {
+                ActivityDelegate activityDelegate = activity.Delegates[i];
+
+                if (activityDelegate.Handler != null)
+                {
+                    yield return activityDelegate.Handler;
+                }
+            }
+
+            for (i = 0; i < activity.ImportedDelegates.Count; i++)
+            {
+                ActivityDelegate activityDelegate = activity.ImportedDelegates[i];
+
+                if (activityDelegate.Handler != null)
+                {
+                    yield return activityDelegate.Handler;
+                }
+            }
+
+            for (i = 0; i < activity.ImplementationDelegates.Count; i++)
+            {
+                ActivityDelegate activityDelegate = activity.ImplementationDelegates[i];
+
+                if (activityDelegate.Handler != null)
+                {
+                    yield return activityDelegate.Handler;
+                }
+            }
+        }
+
+        public static Version GetImplementationVersion(Activity activity)
+        {
+            if (activity == null)
+            {
+                throw FxTrace.Exception.ArgumentNull("activity");
+            }
+
+            return activity.ImplementationVersion;
+        }
+
+        public static bool CanInduceIdle(Activity activity)
+        {
+            if (activity == null)
+            {
+                throw FxTrace.Exception.ArgumentNull("activity");
+            }
+
+            if (!activity.IsMetadataCached)
+            {
+                IList<ValidationError> validationErrors = null;
+
+                ActivityUtilities.CacheRootMetadata(activity, new ActivityLocationReferenceEnvironment(), ProcessActivityTreeOptions.FullCachingOptions, null, ref validationErrors);
+
+                ActivityValidationServices.ThrowIfViolationsExist(validationErrors);
+            }
+
+            return activity.InternalCanInduceIdle;
+        }
+    }
+}