Helpers.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / WF / Activities / Rules / Helpers.cs / 1305376 / Helpers.cs
                        

                        
                            // ---------------------------------------------------------------------------- 
// Copyright (C) 2006 Microsoft Corporation All Rights Reserved
// ---------------------------------------------------------------------------

#define CODE_ANALYSIS 
using System.CodeDom;
using System.Collections; 
using System.ComponentModel.Design.Serialization; 
using System.Diagnostics.CodeAnalysis;
using System.Globalization; 
using System.IO;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Compiler;
using System.Workflow.ComponentModel.Design; 
using System.Workflow.ComponentModel.Serialization;
using System.Xml; 
using System.Reflection; 
using System.Diagnostics;
using System.Workflow.Activities.Common; 

namespace System.Workflow.Activities.Rules
{
    internal static class ConditionHelper 
    {
        internal static Type GetContextType(ITypeProvider typeProvider, Activity currentActivity) 
        { 
            Type contextType = null;
            string className = String.Empty; 
            Activity rootActivity = null;

            if (Helpers.IsActivityLocked(currentActivity))
            { 
                rootActivity = Helpers.GetDeclaringActivity(currentActivity);
            } 
            else 
            {
                rootActivity = Helpers.GetRootActivity(currentActivity); 
            }

            if (rootActivity != null)
            { 
                className = rootActivity.GetValue(WorkflowMarkupSerializer.XClassProperty) as string;
                if (!String.IsNullOrEmpty(className)) 
                    contextType = typeProvider.GetType(className, false); 

                if (contextType == null) 
                    contextType = typeProvider.GetType(rootActivity.GetType().FullName);

                // If all else fails (likely, we don't have a type provider), it's the root activity type.
                if (contextType == null) 
                    contextType = rootActivity.GetType();
            } 
 
            return contextType;
        } 

        /// 

        /// Is type a nullable value type (e.g. double?)?
        /// 
 
        /// 
        ///  
        internal static bool IsNullableValueType(Type type) 
        {
            return ((type.IsValueType) && (type.IsGenericType) && (type.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))); 
        }

        /// 

        /// Is type a standard value type (i.e. not Nullable)? 
        /// 
        ///  
        ///  
        internal static bool IsNonNullableValueType(Type type)
        { 
            return ((type.IsValueType) && (!type.IsGenericType) && (type != typeof(string)));
        }

        internal static object CloneObject(object original) 
        {
            if (original == null) 
                return null; 

            if (original.GetType().IsValueType) 
                return original;

            ICloneable cloneable = original as ICloneable;
            if (cloneable != null) 
                return cloneable.Clone();
 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.NotCloneable, original.GetType().FullName); 
            throw new NotSupportedException(message);
        } 

        internal static void CloneUserData(CodeObject original, CodeObject result)
        {
            // clone UserData, if possible 
            foreach (object key in original.UserData.Keys)
            { 
                object newKey = CloneObject(key); 
                object newValue = CloneObject(original.UserData[key]);
                result.UserData.Add(newKey, newValue); 
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")] 
        internal static RuleDefinitions Load_Rules_DT(IServiceProvider serviceProvider, DependencyObject activity)
        { 
            RuleDefinitions rules = (RuleDefinitions)activity.GetValue(RuleDefinitions.RuleDefinitionsProperty); 
            if (rules == null)
            { 
                WorkflowDesignerLoader loader = (WorkflowDesignerLoader)serviceProvider.GetService(typeof(WorkflowDesignerLoader));
                if (loader != null)
                {
                    string rulesFileName = string.Empty; 
                    if (!string.IsNullOrEmpty(loader.FileName))
                        rulesFileName = Path.Combine(Path.GetDirectoryName(loader.FileName), Path.GetFileNameWithoutExtension(loader.FileName)); 
                    rulesFileName += ".rules"; 

                    try 
                    {
                        using (TextReader ruleFileReader = loader.GetFileReader(rulesFileName))
                        {
                            if (ruleFileReader == null) 
                            {
                                rules = new RuleDefinitions(); 
                            } 
                            else
                            { 
                                using (XmlReader xmlReader = XmlReader.Create(ruleFileReader))
                                    rules = new WorkflowMarkupSerializer().Deserialize(xmlReader) as RuleDefinitions;
                            }
                        } 
                    }
                    catch (Exception) 
                    { 
                        rules = new RuleDefinitions();
                        // 
                    }
                }
                activity.SetValue(RuleDefinitions.RuleDefinitionsProperty, rules);
            } 
            return rules;
        } 
 
        internal static void Flush_Rules_DT(IServiceProvider serviceProvider, Activity activity)
        { 
            RuleDefinitions rules = (RuleDefinitions)activity.GetValue(RuleDefinitions.RuleDefinitionsProperty);
            if (rules != null)
            {
                WorkflowDesignerLoader loader = (WorkflowDesignerLoader)serviceProvider.GetService(typeof(WorkflowDesignerLoader)); 
                if (loader != null)
                { 
                    string rulesFileName = string.Empty; 
                    if (!string.IsNullOrEmpty(loader.FileName))
                        rulesFileName = Path.Combine(Path.GetDirectoryName(loader.FileName), Path.GetFileNameWithoutExtension(loader.FileName)); 
                    rulesFileName += ".rules";

                    using (TextWriter ruleFileWriter = loader.GetFileWriter(rulesFileName))
                    { 
                        if (ruleFileWriter != null)
                        { 
                            using (XmlWriter xmlWriter = Helpers.CreateXmlWriter(ruleFileWriter)) 
                            {
                    DesignerSerializationManager designerSerializationManager = new DesignerSerializationManager(serviceProvider); 
                    using (designerSerializationManager.CreateSession())
                    {
                            new WorkflowMarkupSerializer().Serialize(designerSerializationManager, xmlWriter, rules);
                    } 
                            }
 
                        } 
                    }
                } 
            }
        }

        internal static RuleDefinitions Load_Rules_RT(Activity declaringActivity) 
        {
            RuleDefinitions rules = declaringActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions; 
            if (rules == null) 
            {
                rules = ConditionHelper.GetRuleDefinitionsFromManifest(declaringActivity.GetType()); 
                if (rules != null)
                    declaringActivity.SetValue(RuleDefinitions.RuleDefinitionsProperty, rules);
            }
            return rules; 
        }
 
        // To improve performance, cache the RuleDefinitions deserialized from 
        // .rules resources keyed by the type of activity.
        static Hashtable cloneableOrNullRulesResources = new Hashtable(); 
        // It is unfortunate, however, that cloning might not always succeed, we will keep them here.
        static Hashtable uncloneableRulesResources = new Hashtable();

        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; 
        }
    } 

    internal static class EnumHelper
    {
        [SuppressMessage("Microsoft.Performance", "CA1803:AvoidCostlyCallsWherePossible")] 
        public static Type GetUnderlyingType(Type type)
        { 
            Type underlyingType = typeof(int); 
            if (type.GetType().FullName.Equals("System.Workflow.ComponentModel.Compiler.DesignTimeType", StringComparison.Ordinal))// designTimeType = type as System.Workflow.ComponentModel.Compiler.DesignTimeType;
            { 
                //this is a design time type, need to get the enum type data out of it
                MethodInfo methodInfo = type.GetType().GetMethod("GetEnumType");
                Debug.Assert(methodInfo != null, "Missing GetEnumType method on the DesignTimeType!");
                if (methodInfo != null) 
                {
                    Type result = methodInfo.Invoke(type, new object[0]) as Type; 
                    underlyingType = (result != null) ? result : underlyingType; 
                }
            } 
            else
            {
                underlyingType = Enum.GetUnderlyingType(type);
            } 

            return underlyingType; 
        } 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
// ---------------------------------------------------------------------------- 
// Copyright (C) 2006 Microsoft Corporation All Rights Reserved
// ---------------------------------------------------------------------------

#define CODE_ANALYSIS 
using System.CodeDom;
using System.Collections; 
using System.ComponentModel.Design.Serialization; 
using System.Diagnostics.CodeAnalysis;
using System.Globalization; 
using System.IO;
using System.Workflow.ComponentModel;
using System.Workflow.ComponentModel.Compiler;
using System.Workflow.ComponentModel.Design; 
using System.Workflow.ComponentModel.Serialization;
using System.Xml; 
using System.Reflection; 
using System.Diagnostics;
using System.Workflow.Activities.Common; 

namespace System.Workflow.Activities.Rules
{
    internal static class ConditionHelper 
    {
        internal static Type GetContextType(ITypeProvider typeProvider, Activity currentActivity) 
        { 
            Type contextType = null;
            string className = String.Empty; 
            Activity rootActivity = null;

            if (Helpers.IsActivityLocked(currentActivity))
            { 
                rootActivity = Helpers.GetDeclaringActivity(currentActivity);
            } 
            else 
            {
                rootActivity = Helpers.GetRootActivity(currentActivity); 
            }

            if (rootActivity != null)
            { 
                className = rootActivity.GetValue(WorkflowMarkupSerializer.XClassProperty) as string;
                if (!String.IsNullOrEmpty(className)) 
                    contextType = typeProvider.GetType(className, false); 

                if (contextType == null) 
                    contextType = typeProvider.GetType(rootActivity.GetType().FullName);

                // If all else fails (likely, we don't have a type provider), it's the root activity type.
                if (contextType == null) 
                    contextType = rootActivity.GetType();
            } 
 
            return contextType;
        } 

        /// 

        /// Is type a nullable value type (e.g. double?)?
        /// 
 
        /// 
        ///  
        internal static bool IsNullableValueType(Type type) 
        {
            return ((type.IsValueType) && (type.IsGenericType) && (type.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))); 
        }

        /// 

        /// Is type a standard value type (i.e. not Nullable)? 
        /// 
        ///  
        ///  
        internal static bool IsNonNullableValueType(Type type)
        { 
            return ((type.IsValueType) && (!type.IsGenericType) && (type != typeof(string)));
        }

        internal static object CloneObject(object original) 
        {
            if (original == null) 
                return null; 

            if (original.GetType().IsValueType) 
                return original;

            ICloneable cloneable = original as ICloneable;
            if (cloneable != null) 
                return cloneable.Clone();
 
            string message = string.Format(CultureInfo.CurrentCulture, Messages.NotCloneable, original.GetType().FullName); 
            throw new NotSupportedException(message);
        } 

        internal static void CloneUserData(CodeObject original, CodeObject result)
        {
            // clone UserData, if possible 
            foreach (object key in original.UserData.Keys)
            { 
                object newKey = CloneObject(key); 
                object newValue = CloneObject(original.UserData[key]);
                result.UserData.Add(newKey, newValue); 
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")] 
        internal static RuleDefinitions Load_Rules_DT(IServiceProvider serviceProvider, DependencyObject activity)
        { 
            RuleDefinitions rules = (RuleDefinitions)activity.GetValue(RuleDefinitions.RuleDefinitionsProperty); 
            if (rules == null)
            { 
                WorkflowDesignerLoader loader = (WorkflowDesignerLoader)serviceProvider.GetService(typeof(WorkflowDesignerLoader));
                if (loader != null)
                {
                    string rulesFileName = string.Empty; 
                    if (!string.IsNullOrEmpty(loader.FileName))
                        rulesFileName = Path.Combine(Path.GetDirectoryName(loader.FileName), Path.GetFileNameWithoutExtension(loader.FileName)); 
                    rulesFileName += ".rules"; 

                    try 
                    {
                        using (TextReader ruleFileReader = loader.GetFileReader(rulesFileName))
                        {
                            if (ruleFileReader == null) 
                            {
                                rules = new RuleDefinitions(); 
                            } 
                            else
                            { 
                                using (XmlReader xmlReader = XmlReader.Create(ruleFileReader))
                                    rules = new WorkflowMarkupSerializer().Deserialize(xmlReader) as RuleDefinitions;
                            }
                        } 
                    }
                    catch (Exception) 
                    { 
                        rules = new RuleDefinitions();
                        // 
                    }
                }
                activity.SetValue(RuleDefinitions.RuleDefinitionsProperty, rules);
            } 
            return rules;
        } 
 
        internal static void Flush_Rules_DT(IServiceProvider serviceProvider, Activity activity)
        { 
            RuleDefinitions rules = (RuleDefinitions)activity.GetValue(RuleDefinitions.RuleDefinitionsProperty);
            if (rules != null)
            {
                WorkflowDesignerLoader loader = (WorkflowDesignerLoader)serviceProvider.GetService(typeof(WorkflowDesignerLoader)); 
                if (loader != null)
                { 
                    string rulesFileName = string.Empty; 
                    if (!string.IsNullOrEmpty(loader.FileName))
                        rulesFileName = Path.Combine(Path.GetDirectoryName(loader.FileName), Path.GetFileNameWithoutExtension(loader.FileName)); 
                    rulesFileName += ".rules";

                    using (TextWriter ruleFileWriter = loader.GetFileWriter(rulesFileName))
                    { 
                        if (ruleFileWriter != null)
                        { 
                            using (XmlWriter xmlWriter = Helpers.CreateXmlWriter(ruleFileWriter)) 
                            {
                    DesignerSerializationManager designerSerializationManager = new DesignerSerializationManager(serviceProvider); 
                    using (designerSerializationManager.CreateSession())
                    {
                            new WorkflowMarkupSerializer().Serialize(designerSerializationManager, xmlWriter, rules);
                    } 
                            }
 
                        } 
                    }
                } 
            }
        }

        internal static RuleDefinitions Load_Rules_RT(Activity declaringActivity) 
        {
            RuleDefinitions rules = declaringActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions; 
            if (rules == null) 
            {
                rules = ConditionHelper.GetRuleDefinitionsFromManifest(declaringActivity.GetType()); 
                if (rules != null)
                    declaringActivity.SetValue(RuleDefinitions.RuleDefinitionsProperty, rules);
            }
            return rules; 
        }
 
        // To improve performance, cache the RuleDefinitions deserialized from 
        // .rules resources keyed by the type of activity.
        static Hashtable cloneableOrNullRulesResources = new Hashtable(); 
        // It is unfortunate, however, that cloning might not always succeed, we will keep them here.
        static Hashtable uncloneableRulesResources = new Hashtable();

        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; 
        }
    } 

    internal static class EnumHelper
    {
        [SuppressMessage("Microsoft.Performance", "CA1803:AvoidCostlyCallsWherePossible")] 
        public static Type GetUnderlyingType(Type type)
        { 
            Type underlyingType = typeof(int); 
            if (type.GetType().FullName.Equals("System.Workflow.ComponentModel.Compiler.DesignTimeType", StringComparison.Ordinal))// designTimeType = type as System.Workflow.ComponentModel.Compiler.DesignTimeType;
            { 
                //this is a design time type, need to get the enum type data out of it
                MethodInfo methodInfo = type.GetType().GetMethod("GetEnumType");
                Debug.Assert(methodInfo != null, "Missing GetEnumType method on the DesignTimeType!");
                if (methodInfo != null) 
                {
                    Type result = methodInfo.Invoke(type, new object[0]) as Type; 
                    underlyingType = (result != null) ? result : underlyingType; 
                }
            } 
            else
            {
                underlyingType = Enum.GetUnderlyingType(type);
            } 

            return underlyingType; 
        } 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• ValidatorCollection.cs
• CustomError.cs
• InputScope.cs
• ClipboardProcessor.cs
• RemoteCryptoDecryptRequest.cs
• ScriptDescriptor.cs
• IItemProperties.cs
• TextRangeBase.cs
• DbDataSourceEnumerator.cs
• PagedDataSource.cs
• HttpResponse.cs
• XNodeNavigator.cs
• AssemblyAssociatedContentFileAttribute.cs
• TCPClient.cs
• ProfileSection.cs
• ConfigXmlCDataSection.cs
• ClientApiGenerator.cs
• DockPanel.cs
• ExpandButtonVisibilityConverter.cs
• AppDomainProtocolHandler.cs
• SqlClientFactory.cs
• TrayIconDesigner.cs
• RijndaelManagedTransform.cs
• SpAudioStreamWrapper.cs
• Command.cs
• KeyMatchBuilder.cs
• UserMapPath.cs
• LongValidatorAttribute.cs
• ApplicationFileParser.cs
• ProviderSettingsCollection.cs
• ProcessModelSection.cs
• AmbientProperties.cs
• DownloadProgressEventArgs.cs
• FlatButtonAppearance.cs
• DesignerObject.cs
• SafeThreadHandle.cs
• HttpHandlerActionCollection.cs
• Html32TextWriter.cs
• DataGridViewTextBoxColumn.cs
• ExpressionParser.cs
• DeleteBookmarkScope.cs
• ColumnResizeUndoUnit.cs
• WebPartConnectionsCloseVerb.cs
• TextSelectionHelper.cs
• OperationResponse.cs
• DoubleLinkList.cs
• XmlSerializerFactory.cs
• X509SecurityToken.cs
• CollectionBuilder.cs
• TypeHelper.cs
• EmptyCollection.cs
• DataGridViewRow.cs
• DefaultEvaluationContext.cs
• Translator.cs
• SqlParameter.cs
• ColorMatrix.cs
• XmlReturnWriter.cs
• HtmlDocument.cs
• WaitHandle.cs
• coordinator.cs
• DataBoundLiteralControl.cs
• Visitors.cs
• TileBrush.cs
• XamlReader.cs
• DeclaredTypeElementCollection.cs
• PathNode.cs
• SQLMoney.cs
• EncoderExceptionFallback.cs
• Double.cs
• ChooseAction.cs
• ViewgenGatekeeper.cs
• PropertyIDSet.cs
• XmlHierarchicalDataSourceView.cs
• PromptBuilder.cs
• Subtree.cs
• TypeResolvingOptionsAttribute.cs
• DateTimePicker.cs
• SecurityAlgorithmSuite.cs
• RequiredAttributeAttribute.cs
• AlternateViewCollection.cs
• _ChunkParse.cs
• XhtmlBasicSelectionListAdapter.cs
• CacheChildrenQuery.cs
• Pts.cs
• ApplicationFileParser.cs
• SHA1CryptoServiceProvider.cs
• UriScheme.cs
• DesignerLabelAdapter.cs
• ProcessHostConfigUtils.cs
• ContextCorrelationInitializer.cs
• XmlSchemaAny.cs
• IndexerNameAttribute.cs
• InstanceValue.cs
• CookieParameter.cs
• GeneralTransform3D.cs
• Color.cs
• UnsafeNetInfoNativeMethods.cs
• IisTraceWebEventProvider.cs
• SizeAnimation.cs
• FormsIdentity.cs