Exemple #1
0
        private void AddInstanceExtension(WorkflowInstanceExtensionProvider extensionProvider)
        {
            Fx.Assert(this.instanceExtensions != null, "instanceExtensions should be setup by now");
            var newExtension = extensionProvider.ProvideValue();

            if (newExtension is SymbolResolver)
            {
                throw FxTrace.Exception.AsError(new InvalidOperationException(SR.SymbolResolverMustBeSingleton));
            }

            // for IWorkflowInstance we key off the type of the value, not the declared type
            if (!this.shouldSetInstanceForInstanceExtensions && newExtension is IWorkflowInstanceExtension)
            {
                this.shouldSetInstanceForInstanceExtensions = true;
            }
            if (!this.hasTrackingParticipant && extensionProvider.IsMatch <TrackingParticipant>(newExtension))
            {
                this.hasTrackingParticipant = true;
            }
            if (!this.hasPersistenceModule && extensionProvider.IsMatch <IPersistencePipelineModule>(newExtension))
            {
                this.hasPersistenceModule = true;
            }

            this.instanceExtensions?.Add(new KeyValuePair <WorkflowInstanceExtensionProvider, object>(extensionProvider, newExtension));

            WorkflowInstanceExtensionManager.AddExtensionClosure(newExtension, ref this.additionalInstanceExtensions, ref this.hasTrackingParticipant, ref this.hasPersistenceModule);
        }
Exemple #2
0
 // locks down the given extensions manager and runs cache metadata on the workflow definition
 protected void RegisterExtensionManager(WorkflowInstanceExtensionManager extensionManager)
 {
     ValidateWorkflow(extensionManager);
     this.extensions = WorkflowInstanceExtensionManager.CreateInstanceExtensions(this.WorkflowDefinition, extensionManager);
     if (this.extensions != null)
     {
         this.HasPersistenceModule = this.extensions.HasPersistenceModule;
     }
 }
Exemple #3
0
 void ValidateWorkflow(WorkflowInstanceExtensionManager extensionManager)
 {
     if (!WorkflowDefinition.IsRuntimeReady)
     {
         LocationReferenceEnvironment localEnvironment = this.hostEnvironment;
         if (localEnvironment == null)
         {
             LocationReferenceEnvironment parentEnvironment = null;
             if (extensionManager != null && extensionManager.SymbolResolver != null)
             {
                 parentEnvironment = extensionManager.SymbolResolver.AsLocationReferenceEnvironment();
             }
             localEnvironment = new ActivityLocationReferenceEnvironment(parentEnvironment);
         }
         IList <ValidationError> validationErrors = null;
         ActivityUtilities.CacheRootMetadata(WorkflowDefinition, localEnvironment, ProcessActivityTreeOptions.FullCachingOptions, null, ref validationErrors);
         ActivityValidationServices.ThrowIfViolationsExist(validationErrors);
     }
 }
Exemple #4
0
        private void AddInstanceExtension(WorkflowInstanceExtensionProvider extensionProvider)
        {
            object obj2 = extensionProvider.ProvideValue();

            if (obj2 is SymbolResolver)
            {
                throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.SymbolResolverMustBeSingleton));
            }
            if (!this.shouldSetInstanceForInstanceExtensions && (obj2 is IWorkflowInstanceExtension))
            {
                this.shouldSetInstanceForInstanceExtensions = true;
            }
            if (!this.hasTrackingParticipant && extensionProvider.IsMatch <TrackingParticipant>(obj2))
            {
                this.hasTrackingParticipant = true;
            }
            if (!this.hasPersistenceModule && extensionProvider.IsMatch <IPersistencePipelineModule>(obj2))
            {
                this.hasPersistenceModule = true;
            }
            this.instanceExtensions.Add(new KeyValuePair <WorkflowInstanceExtensionProvider, object>(extensionProvider, obj2));
            WorkflowInstanceExtensionManager.AddExtensionClosure(obj2, ref this.additionalInstanceExtensions, ref this.hasTrackingParticipant, ref this.hasPersistenceModule);
        }
 internal static WorkflowInstanceExtensionCollection CreateInstanceExtensions(Activity workflowDefinition, WorkflowInstanceExtensionManager extensionManager)
 {
     Fx.Assert(workflowDefinition.IsRuntimeReady, "activity should be ready with extensions after a successful CacheMetadata call");
     if (extensionManager != null)
     {
         extensionManager.MakeReadOnly();
         return(new WorkflowInstanceExtensionCollection(workflowDefinition, extensionManager));
     }
     else if ((workflowDefinition.DefaultExtensionsCount > 0) || (workflowDefinition.RequiredExtensionTypesCount > 0))
     {
         return(new WorkflowInstanceExtensionCollection(workflowDefinition, null));
     }
     else
     {
         return(null);
     }
 }
Exemple #6
0
        internal WorkflowInstanceExtensionCollection(Activity workflowDefinition, WorkflowInstanceExtensionManager extensionManager)
        {
            Dictionary <Type, WorkflowInstanceExtensionProvider> dictionary;
            HashSet <Type> set;

            this.extensionManager = extensionManager;
            int capacity = 0;

            if (extensionManager != null)
            {
                capacity = extensionManager.ExtensionProviders.Count;
                this.hasTrackingParticipant = extensionManager.HasSingletonTrackingParticipant;
                this.hasPersistenceModule   = extensionManager.HasSingletonPersistenceModule;
                this.allSingletonExtensions = this.extensionManager.GetAllSingletonExtensions();
            }
            else
            {
                this.allSingletonExtensions = WorkflowInstanceExtensionManager.EmptySingletonExtensions;
            }
            Dictionary <Type, WorkflowInstanceExtensionProvider> dictionary2 = null;

            if (workflowDefinition.GetActivityExtensionInformation(out dictionary, out set))
            {
                HashSet <Type> extensionTypes = new HashSet <Type>();
                if (extensionManager != null)
                {
                    extensionManager.AddAllExtensionTypes(extensionTypes);
                }
                if (dictionary != null)
                {
                    dictionary2 = new Dictionary <Type, WorkflowInstanceExtensionProvider>(dictionary.Count);
                    foreach (KeyValuePair <Type, WorkflowInstanceExtensionProvider> pair in dictionary)
                    {
                        Type key = pair.Key;
                        if (!System.Runtime.TypeHelper.ContainsCompatibleType(extensionTypes, key))
                        {
                            List <Type> list = null;
                            bool        flag = false;
                            foreach (Type type2 in dictionary2.Keys)
                            {
                                if (System.Runtime.TypeHelper.AreReferenceTypesCompatible(type2, key))
                                {
                                    flag = true;
                                    break;
                                }
                                if (System.Runtime.TypeHelper.AreReferenceTypesCompatible(key, type2))
                                {
                                    if (list == null)
                                    {
                                        list = new List <Type>();
                                    }
                                    list.Add(type2);
                                }
                            }
                            if (list != null)
                            {
                                for (int i = 0; i < list.Count; i++)
                                {
                                    dictionary2.Remove(list[i]);
                                }
                            }
                            if (!flag)
                            {
                                dictionary2.Add(key, pair.Value);
                            }
                        }
                    }
                    if (dictionary2.Count > 0)
                    {
                        extensionTypes.UnionWith(dictionary2.Keys);
                        capacity += dictionary2.Count;
                    }
                }
                if ((set != null) && (set.Count > 0))
                {
                    foreach (Type type3 in set)
                    {
                        if (!System.Runtime.TypeHelper.ContainsCompatibleType(extensionTypes, type3))
                        {
                            throw FxTrace.Exception.AsError(new ValidationException(System.Activities.SR.RequiredExtensionTypeNotFound(type3.ToString())));
                        }
                    }
                }
            }
            if (capacity > 0)
            {
                this.instanceExtensions = new List <KeyValuePair <WorkflowInstanceExtensionProvider, object> >(capacity);
                if (extensionManager != null)
                {
                    List <KeyValuePair <Type, WorkflowInstanceExtensionProvider> > extensionProviders = extensionManager.ExtensionProviders;
                    for (int j = 0; j < extensionProviders.Count; j++)
                    {
                        KeyValuePair <Type, WorkflowInstanceExtensionProvider> pair2 = extensionProviders[j];
                        this.AddInstanceExtension(pair2.Value);
                    }
                }
                if (dictionary2 != null)
                {
                    foreach (WorkflowInstanceExtensionProvider provider in dictionary2.Values)
                    {
                        this.AddInstanceExtension(provider);
                    }
                }
            }
        }
Exemple #7
0
        internal WorkflowInstanceExtensionCollection(Activity workflowDefinition, WorkflowInstanceExtensionManager extensionManager)
        {
            this.extensionManager = extensionManager;

            int extensionProviderCount = 0;

            if (extensionManager != null)
            {
                extensionProviderCount      = extensionManager.ExtensionProviders.Count;
                this.hasTrackingParticipant = extensionManager.HasSingletonTrackingParticipant;
                this.hasPersistenceModule   = extensionManager.HasSingletonPersistenceModule;

                // create an uber-IEnumerable to simplify our iteration code
                this.allSingletonExtensions = this.extensionManager.GetAllSingletonExtensions();
            }
            else
            {
                this.allSingletonExtensions = WorkflowInstanceExtensionManager.EmptySingletonExtensions;
            }

            // Resolve activity extensions
            Dictionary <Type, WorkflowInstanceExtensionProvider> filteredActivityExtensionProviders = null;

            if (workflowDefinition.GetActivityExtensionInformation(out Dictionary <Type, WorkflowInstanceExtensionProvider> activityExtensionProviders, out HashSet <Type> requiredActivityExtensionTypes))
            {
                // a) filter out the extension Types that were already configured by the host. Note that only "primary" extensions are in play here, not
                // "additional" extensions
                HashSet <Type> allExtensionTypes = new HashSet <Type>();
                if (extensionManager != null)
                {
                    extensionManager.AddAllExtensionTypes(allExtensionTypes);
                }

                if (activityExtensionProviders != null)
                {
                    filteredActivityExtensionProviders = new Dictionary <Type, WorkflowInstanceExtensionProvider>(activityExtensionProviders.Count);
                    foreach (KeyValuePair <Type, WorkflowInstanceExtensionProvider> keyedActivityExtensionProvider in activityExtensionProviders)
                    {
                        Type newExtensionProviderType = keyedActivityExtensionProvider.Key;
                        if (!TypeHelper.ContainsCompatibleType(allExtensionTypes, newExtensionProviderType))
                        {
                            // first see if the new provider supersedes any existing ones
                            List <Type> typesToRemove            = null;
                            bool        skipNewExtensionProvider = false;
                            foreach (Type existingExtensionProviderType in filteredActivityExtensionProviders.Keys)
                            {
                                // Use AreReferenceTypesCompatible for performance since we know that all of these must be reference types
                                if (TypeHelper.AreReferenceTypesCompatible(existingExtensionProviderType, newExtensionProviderType))
                                {
                                    skipNewExtensionProvider = true;
                                    break;
                                }

                                if (TypeHelper.AreReferenceTypesCompatible(newExtensionProviderType, existingExtensionProviderType))
                                {
                                    if (typesToRemove == null)
                                    {
                                        typesToRemove = new List <Type>();
                                    }
                                    typesToRemove.Add(existingExtensionProviderType);
                                }
                            }

                            // prune unnecessary extension providers (either superseded by the new extension or by an existing extension that supersedes them both)
                            if (typesToRemove != null)
                            {
                                for (int i = 0; i < typesToRemove.Count; i++)
                                {
                                    filteredActivityExtensionProviders.Remove(typesToRemove[i]);
                                }
                            }

                            // and add a new extension if necessary
                            if (!skipNewExtensionProvider)
                            {
                                filteredActivityExtensionProviders.Add(newExtensionProviderType, keyedActivityExtensionProvider.Value);
                            }
                        }
                    }
                    if (filteredActivityExtensionProviders.Count > 0)
                    {
                        allExtensionTypes.UnionWith(filteredActivityExtensionProviders.Keys);
                        extensionProviderCount += filteredActivityExtensionProviders.Count;
                    }
                }

                // b) Validate that all required extensions will be provided
                if (requiredActivityExtensionTypes != null && requiredActivityExtensionTypes.Count > 0)
                {
                    foreach (Type requiredType in requiredActivityExtensionTypes)
                    {
                        if (!TypeHelper.ContainsCompatibleType(allExtensionTypes, requiredType))
                        {
                            throw FxTrace.Exception.AsError(new ValidationException(SR.RequiredExtensionTypeNotFound(requiredType.ToString())));
                        }
                    }
                }
            }

            // Finally, if our checks of passed, resolve our delegates
            if (extensionProviderCount > 0)
            {
                this.instanceExtensions = new List <KeyValuePair <WorkflowInstanceExtensionProvider, object> >(extensionProviderCount);

                if (extensionManager != null)
                {
                    List <KeyValuePair <Type, WorkflowInstanceExtensionProvider> > extensionProviders = extensionManager.ExtensionProviders;
                    for (int i = 0; i < extensionProviders.Count; i++)
                    {
                        KeyValuePair <Type, WorkflowInstanceExtensionProvider> extensionProvider = extensionProviders[i];
                        AddInstanceExtension(extensionProvider.Value);
                    }
                }

                if (filteredActivityExtensionProviders != null)
                {
                    foreach (WorkflowInstanceExtensionProvider extensionProvider in filteredActivityExtensionProviders.Values)
                    {
                        AddInstanceExtension(extensionProvider);
                    }
                }
            }
        }
Exemple #8
0
 protected void RegisterExtensionManager(WorkflowInstanceExtensionManager extensionManager)
 {
     throw new NotImplementedException();
 }
 internal static WorkflowInstanceExtensionCollection CreateInstanceExtensions(Activity workflowDefinition, WorkflowInstanceExtensionManager extensionManager)
 {
     if (extensionManager != null)
     {
         extensionManager.MakeReadOnly();
         return(new WorkflowInstanceExtensionCollection(workflowDefinition, extensionManager));
     }
     if ((workflowDefinition.DefaultExtensionsCount <= 0) && (workflowDefinition.RequiredExtensionTypesCount <= 0))
     {
         return(null);
     }
     return(new WorkflowInstanceExtensionCollection(workflowDefinition, null));
 }