internal static RuleDefinitions GetRuleDefinitionsFromManifest(Type workflowType)
        {
            if (workflowType == null)
            {
                throw new ArgumentNullException("workflowType");
            }
            RuleDefinitions definitions = null;

            if (cloneableOrNullRulesResources.ContainsKey(workflowType))
            {
                definitions = (RuleDefinitions)cloneableOrNullRulesResources[workflowType];
                if (definitions != null)
                {
                    definitions = definitions.Clone();
                }
                return(definitions);
            }
            string name = workflowType.Name + ".rules";
            Stream manifestResourceStream = workflowType.Module.Assembly.GetManifestResourceStream(workflowType, name);

            if (manifestResourceStream == null)
            {
                manifestResourceStream = workflowType.Module.Assembly.GetManifestResourceStream(name);
            }
            if (manifestResourceStream != null)
            {
                using (StreamReader reader = new StreamReader(manifestResourceStream))
                {
                    using (XmlReader reader2 = XmlReader.Create(reader))
                    {
                        definitions = new WorkflowMarkupSerializer().Deserialize(reader2) as RuleDefinitions;
                    }
                }
            }
            if (!uncloneableRulesResources.ContainsKey(workflowType))
            {
                try
                {
                    RuleDefinitions definitions2 = definitions;
                    if (definitions != null)
                    {
                        definitions = definitions.Clone();
                    }
                    lock (cloneableOrNullRulesResources)
                    {
                        cloneableOrNullRulesResources[workflowType] = definitions2;
                    }
                }
                catch (Exception)
                {
                    lock (uncloneableRulesResources)
                    {
                        uncloneableRulesResources[workflowType] = null;
                    }
                }
            }
            return(definitions);
        }
예제 #2
0
        internal static RuleDefinitions GetRuleDefinitionsFromManifest(Type workflowType)
        {
            if (workflowType == null)
            {
                throw new ArgumentNullException("workflowType");
            }

            RuleDefinitions rules = null;

            if (cloneableOrNullRulesResources.ContainsKey(workflowType))
            {
                rules = (RuleDefinitions)cloneableOrNullRulesResources[workflowType];
                if (rules != null)
                {
                    // This should always succeed, since it is coming out of the cloneable cache
                    rules = rules.Clone();
                }
            }
            else
            {
                string resourceName = workflowType.Name + ".rules";
                Stream stream       = workflowType.Module.Assembly.GetManifestResourceStream(workflowType, resourceName);

                // Try just the .rules file name. This is needed for wfc.exe compilation scenarios.
                if (stream == null)
                {
                    stream = workflowType.Module.Assembly.GetManifestResourceStream(resourceName);
                }

                if (stream != null)
                {
                    using (StreamReader reader = new StreamReader(stream))
                    {
                        using (XmlReader xmlReader = XmlReader.Create(reader))
                            rules = new WorkflowMarkupSerializer().Deserialize(xmlReader) as RuleDefinitions;
                    }
                }
                // Don't know yet whether 'rules' is cloneable, give it a try
                if (!uncloneableRulesResources.ContainsKey(workflowType))
                {
                    try
                    {
                        RuleDefinitions originalRules = rules;
                        if (rules != null)
                        {
                            rules = rules.Clone();
                        }
                        lock (cloneableOrNullRulesResources)
                        {
                            cloneableOrNullRulesResources[workflowType] = originalRules;
                        }
                    }
                    catch (Exception)
                    {
                        lock (uncloneableRulesResources)
                        {
                            uncloneableRulesResources[workflowType] = null;
                        }
                    }
                }
            }
            return(rules);
        }