CompilationUtil.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / whidbey / NetFxQFE / ndp / fx / src / xsp / System / Web / Compilation / CompilationUtil.cs / 1 / CompilationUtil.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

/* 
 * Code related to the  config section 
 *
 * Copyright (c) 1999 Microsoft Corporation 
 */
namespace System.Web.Compilation {

    using System; 
    using System.Web;
    using System.Configuration; 
    using System.Web.UI; 
    using System.Web.Configuration;
    using System.Web.Hosting; 
    using System.Web.Util;
    using System.Globalization;
    using System.Collections;
    using System.CodeDom.Compiler; 
    using System.Security;
    using System.Security.Permissions; 
    using System.Reflection; 

 
    internal static class CompilationUtil {

        internal const string CodeDomProviderOptionPath = "system.codedom/compilers/compiler/ProviderOption/";
 
        internal static bool IsDebuggingEnabled(HttpContext context) {
            CompilationSection compConfig = RuntimeConfig.GetConfig(context).Compilation; 
            return compConfig.Debug; 
        }
 
        internal static bool IsBatchingEnabled(string configPath) {
            CompilationSection config = RuntimeConfig.GetConfig(configPath).Compilation;
            return config.Batch;
        } 

        internal static int GetRecompilationsBeforeAppRestarts() { 
            CompilationSection config = RuntimeConfig.GetAppConfig().Compilation; 
            return config.NumRecompilesBeforeAppRestart;
        } 

        internal static CompilerType GetCodeDefaultLanguageCompilerInfo() {
            return new CompilerType(typeof(Microsoft.VisualBasic.VBCodeProvider), null);
        } 

        internal static CompilerType GetDefaultLanguageCompilerInfo(CompilationSection compConfig, VirtualPath configPath) { 
            if (compConfig == null) { 
                // Get the  config object
                compConfig = RuntimeConfig.GetConfig(configPath).Compilation; 
            }

            // If no default language was specified in config, use VB
            if (compConfig.DefaultLanguage == null) { 
                return GetCodeDefaultLanguageCompilerInfo();
            } 
            else { 
                return compConfig.GetCompilerInfoFromLanguage(compConfig.DefaultLanguage);
            } 
        }

        /*
         * Return a CompilerType that a file name's extension maps to. 
         */
        internal static CompilerType GetCompilerInfoFromVirtualPath(VirtualPath virtualPath) { 
 
            // Get the extension of the source file to compile
            string extension = virtualPath.Extension; 

            // Make sure there is an extension
            if (extension.Length == 0) {
                throw new HttpException( 
                    SR.GetString(SR.Empty_extension, virtualPath));
            } 
 
            return GetCompilerInfoFromExtension(virtualPath, extension);
        } 

        /*
         * Return a CompilerType that a extension maps to.
         */ 
        private static CompilerType GetCompilerInfoFromExtension(VirtualPath configPath, string extension) {
            // Get the  config object 
            CompilationSection config = RuntimeConfig.GetConfig(configPath).Compilation; 

            return config.GetCompilerInfoFromExtension(extension, true /*throwOnFail*/); 
        }

        /*
         * Return a CompilerType that a language maps to. 
         */
        internal static CompilerType GetCompilerInfoFromLanguage(VirtualPath configPath, string language) { 
            // Get the  config object 
            CompilationSection config = RuntimeConfig.GetConfig(configPath).Compilation;
 
            return config.GetCompilerInfoFromLanguage(language);
        }

        internal static CompilerType GetCSharpCompilerInfo( 
            CompilationSection compConfig, VirtualPath configPath) {
 
            if (compConfig == null) { 
                // Get the  config object
                compConfig = RuntimeConfig.GetConfig(configPath).Compilation; 
            }

            if (compConfig.DefaultLanguage == null)
                return new CompilerType(typeof(Microsoft.CSharp.CSharpCodeProvider), null); 

            return compConfig.GetCompilerInfoFromLanguage("c#"); 
        } 

        internal static CodeSubDirectoriesCollection GetCodeSubDirectories() { 
            // Get the  config object
            CompilationSection config = RuntimeConfig.GetAppConfig().Compilation;

            CodeSubDirectoriesCollection codeSubDirectories = config.CodeSubDirectories; 

            // Make sure the config data is valid 
            if (codeSubDirectories != null) { 
                codeSubDirectories.EnsureRuntimeValidation();
            } 

            return codeSubDirectories;
        }
 
        internal static long GetRecompilationHash(CompilationSection ps)
        { 
            HashCodeCombiner recompilationHash = new HashCodeCombiner(); 
            AssemblyCollection assemblies;
            BuildProviderCollection builders; 
            CodeSubDirectoriesCollection codeSubDirs;

            // Combine items from Compilation section
            recompilationHash.AddObject(ps.Debug); 
            recompilationHash.AddObject(ps.Strict);
            recompilationHash.AddObject(ps.Explicit); 
            recompilationHash.AddObject(ps.Batch); 
            recompilationHash.AddObject(ps.OptimizeCompilations);
            recompilationHash.AddObject(ps.BatchTimeout); 
            recompilationHash.AddObject(ps.MaxBatchGeneratedFileSize);
            recompilationHash.AddObject(ps.MaxBatchSize);
            recompilationHash.AddObject(ps.NumRecompilesBeforeAppRestart);
            recompilationHash.AddObject(ps.DefaultLanguage); 
            recompilationHash.AddObject(ps.UrlLinePragmas);
            if (ps.AssemblyPostProcessorTypeInternal != null) { 
                recompilationHash.AddObject(ps.AssemblyPostProcessorTypeInternal.FullName); 
            }
 
            // Combine items from Compilers collection
            foreach (Compiler compiler in ps.Compilers) {
                recompilationHash.AddObject(compiler.Language);
                recompilationHash.AddObject(compiler.Extension); 
                recompilationHash.AddObject(compiler.Type);
                recompilationHash.AddObject(compiler.WarningLevel); 
                recompilationHash.AddObject(compiler.CompilerOptions); 
            }
 
            // Combine items from  section
            foreach (System.Web.Configuration.ExpressionBuilder eb in ps.ExpressionBuilders) {
                recompilationHash.AddObject(eb.ExpressionPrefix);
                recompilationHash.AddObject(eb.Type); 
            }
 
            // Combine items from the Assembly collection 
            assemblies = ps.Assemblies;
 
            if (assemblies.Count == 0) {
                recompilationHash.AddObject("__clearassemblies");
            }
            else { 
                foreach (AssemblyInfo ai in assemblies) {
                    recompilationHash.AddObject(ai.Assembly); 
                } 
            }
 
            // Combine items from the Builders Collection
            builders = ps.BuildProviders;

            if (builders.Count == 0) { 
                recompilationHash.AddObject("__clearbuildproviders");
            } 
            else { 
                foreach (System.Web.Configuration.BuildProvider bp in builders) {
                    recompilationHash.AddObject(bp.Type); 
                    recompilationHash.AddObject(bp.Extension);
                }
            }
 
            codeSubDirs = ps.CodeSubDirectories;
            if (codeSubDirs.Count == 0) { 
                recompilationHash.AddObject("__clearcodesubdirs"); 
            }
            else { 
                foreach (CodeSubDirectory csd in codeSubDirs) {
                    recompilationHash.AddObject(csd.DirectoryName);
                }
            } 

            // Make sure the  section is hashed properly. 
            CompilerInfo[] compilerInfoArray = CodeDomProvider.GetAllCompilerInfo(); 
            if (compilerInfoArray != null) {
                foreach (CompilerInfo info in compilerInfoArray) { 
                    // Ignore it if the type is not valid.
                    if (!info.IsCodeDomProviderTypeValid) {
                        continue;
                    } 

                    CompilerParameters parameters = info.CreateDefaultCompilerParameters(); 
                    string option = parameters.CompilerOptions; 
                    if (!String.IsNullOrEmpty(option)) {
                        Type type = info.CodeDomProviderType; 
                        if (type != null) {
                            recompilationHash.AddObject(type.FullName);
                        }
                        // compilerOptions need to be hashed. 
                        recompilationHash.AddObject(option);
                    } 
 
                    // DevDiv 62998
                    // The tag providerOption needs to be added to the hash, 
                    // as the user could switch between v2 and v3.5.
                    if (info.CodeDomProviderType == null)
                        continue;
 
                    // Add a hash for each providerOption added, specific for each codeDomProvider, so that
                    // if some codedom setting has changed, we know we have to recompile. 
                    System.Collections.Generic.IDictionary providerOptions = GetProviderOptions(info); 
                    if (providerOptions != null && providerOptions.Count > 0) {
                        string codeDomProviderType = info.CodeDomProviderType.FullName; 
                        foreach (string key in providerOptions.Keys) {
                            string value = providerOptions[key];
                            recompilationHash.AddObject(codeDomProviderType + ":" +  key + "=" + value);
                        } 
                    }
                } 
            } 

            return recompilationHash.CombinedHash; 
        }


        /* 
         * Simple wrapper to get the Assemblies
         */ 
        internal static AssemblyCollection GetAssembliesForAppLevel() { 
            // Get the CompilationSection object for the passed in config path
            CompilationSection compilationConfiguration = RuntimeConfig.GetAppConfig().Compilation; 
            return compilationConfiguration.Assemblies;
        }

        /* 
         * Look for a type by name in a collection of assemblies.  If it exists in multiple assemblies,
         * throw an error. 
         */ 
        // Assert reflection in order to call assembly.GetType()
        [ReflectionPermission(SecurityAction.Assert, Flags=ReflectionPermissionFlag.MemberAccess)] 
        internal static Type GetTypeFromAssemblies(AssemblyCollection assembliesCollection, string typeName, bool ignoreCase) {
            if (assembliesCollection == null)
                return null;
 
            Type type = null;
 
            foreach (AssemblyInfo info in assembliesCollection) { 
                Assembly[] assemblies = info.AssemblyInternal;
 
                for (int i = 0; i < assemblies.Length; i++) {
                    Assembly assembly = assemblies[i];
                    Type t = assembly.GetType(typeName, false /*throwOnError*/, ignoreCase);
 
                    if (t == null)
                        continue; 
 
                    // If we had already found a different one, it's an ambiguous type reference
                    if (type != null && t != type) { 
                        throw new HttpException(SR.GetString(
                            SR.Ambiguous_type, typeName,
                            Util.GetAssemblySafePathFromType(type), Util.GetAssemblySafePathFromType(t)));
                    } 

                    // Keep track of it 
                    type = t; 
                }
            } 

            return type;
        }
 

        /* 
         * Return a file provider Type that an extension maps to. 
         */
        internal static Type GetBuildProviderTypeFromExtension(VirtualPath configPath, string extension, 
            BuildProviderAppliesTo neededFor, bool failIfUnknown) {

            // Get the  config object
            CompilationSection config = RuntimeConfig.GetConfig(configPath).Compilation; 

            return GetBuildProviderTypeFromExtension(config, extension, neededFor, failIfUnknown); 
        } 

        internal static Type GetBuildProviderTypeFromExtension(CompilationSection config, string extension, 
            BuildProviderAppliesTo neededFor, bool failIfUnknown) {

            System.Web.Configuration.BuildProvider entry = (System.Web.Configuration.BuildProvider) config.BuildProviders[extension];
 
            Type buildProviderType = null;
            // Never return an IgnoreFileBuildProvider/ForceCopyBuildProvider, since it's just a marker 
            if (entry != null && 
                entry.TypeInternal != typeof(IgnoreFileBuildProvider) &&
                entry.TypeInternal != typeof(ForceCopyBuildProvider)) { 
                buildProviderType = entry.TypeInternal;
            }

            // In updatable precomp mode, only aspx/ascx/master web files need processing.  Ignore the rest. 
            if (neededFor == BuildProviderAppliesTo.Web &&
                BuildManager.PrecompilingForUpdatableDeployment && 
                !typeof(BaseTemplateBuildProvider).IsAssignableFrom(buildProviderType)) { 
                buildProviderType = null;
            } 

            if (buildProviderType != null) {
                // Only return it if it applies to what it's needed for
                if ((neededFor & entry.AppliesToInternal) != 0) 
                    return buildProviderType;
            } 
            // If the extension is registered as a compiler extension, use 
            // a SourceFileBuildProvider to handle it (not supported in Resources directory)
            else if (neededFor != BuildProviderAppliesTo.Resources && 
                config.GetCompilerInfoFromExtension(extension, false /*throwOnFail*/) != null) {
                return typeof(SourceFileBuildProvider);
            }
 
            if (failIfUnknown) {
                throw new HttpException( SR.GetString( 
                    SR.Unknown_buildprovider_extension, extension, neededFor.ToString())); 
            }
 
            return null;
        }

        internal static void CheckCompilerOptionsAllowed(string compilerOptions, bool config, string file, int line) { 

            // If it's empty, we never block it 
            if (String.IsNullOrEmpty(compilerOptions)) 
                return;
 
            // Only allow the use of compilerOptions when we have UnmanagedCode access (ASURT 73678)
            if (!HttpRuntime.HasUnmanagedPermission()) {
                string errorString = SR.GetString(SR.Insufficient_trust_for_attribute, "compilerOptions");
 
                if (config)
                    throw new ConfigurationErrorsException(errorString, file, line); 
                else 
                    throw new HttpException(errorString);
            } 
        }

        // This is used to determine what files need to be copied, and what stub files
        // need to be created during deployment precompilation. 
        // Note: createStub only applies if the method returns false.
        internal static bool NeedToCopyFile(VirtualPath virtualPath, bool updatable, out bool createStub) { 
 
            createStub = false;
 
            // Get the  config object
            CompilationSection config = RuntimeConfig.GetConfig(virtualPath).Compilation;

            string extension = virtualPath.Extension; 

            System.Web.Configuration.BuildProvider entry = (System.Web.Configuration.BuildProvider) config.BuildProviders[extension]; 
 
            if (entry != null) {
                // We only care about 'web' providers.  Everything else we treat as static 
                if ((BuildProviderAppliesTo.Web & entry.AppliesToInternal) == 0)
                    return true;

                // If the provider is a ForceCopyBuildProvider, treat as static 
                if (entry.TypeInternal == typeof(ForceCopyBuildProvider))
                    return true; 
 
                // During updatable precomp, everything needs to be copied over.  However,
                // aspx files that use code beside will later be overwritten by modified 
                // versions (see TemplateParser.CreateModifiedMainDirectiveFileIfNeeded)
                if (entry.TypeInternal != typeof(IgnoreFileBuildProvider) &&
                    BuildManager.PrecompilingForUpdatableDeployment) {
                    return true; 
                }
 
                // There is a real provider, so don't copy the file.  We also need to determine whether 
                // a stub file needs to be created.
 
                createStub = true;

                // Skip the stub file for some non-requestable types
                if (entry.TypeInternal == typeof(UserControlBuildProvider) || 
                    entry.TypeInternal == typeof(MasterPageBuildProvider) ||
                    entry.TypeInternal == typeof(IgnoreFileBuildProvider)) { 
                    createStub = false; 
                }
 
                return false;
            }

            // If the extension is registered as a compiler extension, don't copy 
            if (config.GetCompilerInfoFromExtension(extension, false /*throwOnFail*/) != null) {
                return false; 
            } 

            // Skip the copying for asax and skin files, which are not static even though they 
            // don't have a registered BuildProvider (but don't skip .skin files during
            // updatable precomp).
            //
            if (StringUtil.EqualsIgnoreCase(extension, ".asax")) 
                return false;
            if (!updatable && StringUtil.EqualsIgnoreCase(extension, ThemeDirectoryCompiler.skinExtension)) 
                return false; 

            // 
            // If there is no BuildProvider registered, it's a static file, and should be copied
            //

            return true; 
        }
 
        internal static Type LoadTypeWithChecks(string typeName, Type requiredBaseType, Type requiredBaseType2, ConfigurationElement elem, string propertyName) { 
            Type t = ConfigUtil.GetType(typeName, propertyName, elem);
 
            if (requiredBaseType2 == null) {
                ConfigUtil.CheckAssignableType(requiredBaseType, t, elem, propertyName);
            }
            else { 
                ConfigUtil.CheckAssignableType(requiredBaseType, requiredBaseType2, t, elem, propertyName);
            } 
 
            return t;
        } 

        // Devdiv Bug 57600
        // We need to use the constructor with ProviderOptions to get the v3.5 compiler that was possibly set in config.
        // We first check if there is any providerOptions and invoke the constructor if so. 
        // Otherwise, we fall back to the default constructor.
        internal static CodeDomProvider CreateCodeDomProvider(Type codeDomProviderType) { 
            CodeDomProvider codeDomProvider = CreateCodeDomProviderWithPropertyOptions(codeDomProviderType); 
            if (codeDomProvider != null)
                return codeDomProvider; 
            return (CodeDomProvider)Activator.CreateInstance(codeDomProviderType);
        }

        internal static CodeDomProvider CreateCodeDomProviderNonPublic(Type codeDomProviderType) { 
            CodeDomProvider codeDomProvider = CreateCodeDomProviderWithPropertyOptions(codeDomProviderType);
            if (codeDomProvider != null) 
                return codeDomProvider; 
            return (CodeDomProvider)HttpRuntime.CreateNonPublicInstance(codeDomProviderType);
        } 

        [ReflectionPermission(SecurityAction.Assert, Unrestricted = true)]
        private static CodeDomProvider CreateCodeDomProviderWithPropertyOptions(Type codeDomProviderType) {
            // The following resembles the code in System.CodeDom.CompilerInfo.CreateProvider 
            System.Collections.Generic.IDictionary providerOptions = GetProviderOptions(codeDomProviderType);
            if (providerOptions != null && providerOptions.Count > 0) { 
                Debug.Assert(codeDomProviderType != null, "codeDomProviderType should not be null"); 
                ConstructorInfo ci = codeDomProviderType.GetConstructor(new Type[] { typeof(System.Collections.Generic.IDictionary) });
                if (ci != null) { 
                    return (CodeDomProvider)ci.Invoke(new object[] { providerOptions });
                }
            }
            return null; 
        }
 
        [ReflectionPermission(SecurityAction.Assert, Unrestricted = true)] 
        internal static System.Collections.Generic.IDictionary GetProviderOptions(Type codeDomProviderType) {
            // Using reflection to get the property for the time being. 
            // This could simply return CompilerInfo.PropertyOptions if it goes public in future.
            CodeDomProvider provider = (CodeDomProvider) Activator.CreateInstance(codeDomProviderType);
            if (CodeDomProvider.IsDefinedExtension(provider.FileExtension)) {
                CompilerInfo ci = CodeDomProvider.GetCompilerInfo(CodeDomProvider.GetLanguageFromExtension(provider.FileExtension)); 
                return GetProviderOptions(ci);
            } 
            return null; 
        }
 
        [ReflectionPermission(SecurityAction.Assert, Unrestricted = true)]
        private static System.Collections.Generic.IDictionary GetProviderOptions(CompilerInfo ci) {
            Debug.Assert(ci != null, "CompilerInfo ci should not be null");
            PropertyInfo pi = ci.GetType().GetProperty("ProviderOptions", 
                BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.Instance);
            if (pi != null) 
                return (System.Collections.Generic.IDictionary)pi.GetValue(ci, null); 
            return null;
        } 

        // This returns true only if the version is v3.5
        internal static bool IsCompilerVersion35(Type codeDomProviderType) {
            System.Collections.Generic.IDictionary providerOptions = CompilationUtil.GetProviderOptions(codeDomProviderType); 

            // If providerOptions is available, try processing it. 
            if (providerOptions != null) { 
                string version;
                if (providerOptions.TryGetValue("CompilerVersion", out version)) { 
                    // If providerOptions contains the CompilerVersion key, it has to be either "v2.0" or "v3.5"
                    if (version == "v2.0")
                        return false;
                    else if (version == "v3.5") 
                        return true;
 
                    // If it is not v2.0 or v3.5, we throw an exception. 
                    throw new ConfigurationException(SR.GetString(SR.Invalid_attribute_value, version, CodeDomProviderOptionPath + "CompilerVersion"));
                } 
            }

            // If providerOptions is null, default to v2.0.
            // Or if providerOptions does not contain CompilerVersion, default to v2.0. 
            return false;
        } 
    } 
}
 

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

/* 
 * Code related to the  config section 
 *
 * Copyright (c) 1999 Microsoft Corporation 
 */
namespace System.Web.Compilation {

    using System; 
    using System.Web;
    using System.Configuration; 
    using System.Web.UI; 
    using System.Web.Configuration;
    using System.Web.Hosting; 
    using System.Web.Util;
    using System.Globalization;
    using System.Collections;
    using System.CodeDom.Compiler; 
    using System.Security;
    using System.Security.Permissions; 
    using System.Reflection; 

 
    internal static class CompilationUtil {

        internal const string CodeDomProviderOptionPath = "system.codedom/compilers/compiler/ProviderOption/";
 
        internal static bool IsDebuggingEnabled(HttpContext context) {
            CompilationSection compConfig = RuntimeConfig.GetConfig(context).Compilation; 
            return compConfig.Debug; 
        }
 
        internal static bool IsBatchingEnabled(string configPath) {
            CompilationSection config = RuntimeConfig.GetConfig(configPath).Compilation;
            return config.Batch;
        } 

        internal static int GetRecompilationsBeforeAppRestarts() { 
            CompilationSection config = RuntimeConfig.GetAppConfig().Compilation; 
            return config.NumRecompilesBeforeAppRestart;
        } 

        internal static CompilerType GetCodeDefaultLanguageCompilerInfo() {
            return new CompilerType(typeof(Microsoft.VisualBasic.VBCodeProvider), null);
        } 

        internal static CompilerType GetDefaultLanguageCompilerInfo(CompilationSection compConfig, VirtualPath configPath) { 
            if (compConfig == null) { 
                // Get the  config object
                compConfig = RuntimeConfig.GetConfig(configPath).Compilation; 
            }

            // If no default language was specified in config, use VB
            if (compConfig.DefaultLanguage == null) { 
                return GetCodeDefaultLanguageCompilerInfo();
            } 
            else { 
                return compConfig.GetCompilerInfoFromLanguage(compConfig.DefaultLanguage);
            } 
        }

        /*
         * Return a CompilerType that a file name's extension maps to. 
         */
        internal static CompilerType GetCompilerInfoFromVirtualPath(VirtualPath virtualPath) { 
 
            // Get the extension of the source file to compile
            string extension = virtualPath.Extension; 

            // Make sure there is an extension
            if (extension.Length == 0) {
                throw new HttpException( 
                    SR.GetString(SR.Empty_extension, virtualPath));
            } 
 
            return GetCompilerInfoFromExtension(virtualPath, extension);
        } 

        /*
         * Return a CompilerType that a extension maps to.
         */ 
        private static CompilerType GetCompilerInfoFromExtension(VirtualPath configPath, string extension) {
            // Get the  config object 
            CompilationSection config = RuntimeConfig.GetConfig(configPath).Compilation; 

            return config.GetCompilerInfoFromExtension(extension, true /*throwOnFail*/); 
        }

        /*
         * Return a CompilerType that a language maps to. 
         */
        internal static CompilerType GetCompilerInfoFromLanguage(VirtualPath configPath, string language) { 
            // Get the  config object 
            CompilationSection config = RuntimeConfig.GetConfig(configPath).Compilation;
 
            return config.GetCompilerInfoFromLanguage(language);
        }

        internal static CompilerType GetCSharpCompilerInfo( 
            CompilationSection compConfig, VirtualPath configPath) {
 
            if (compConfig == null) { 
                // Get the  config object
                compConfig = RuntimeConfig.GetConfig(configPath).Compilation; 
            }

            if (compConfig.DefaultLanguage == null)
                return new CompilerType(typeof(Microsoft.CSharp.CSharpCodeProvider), null); 

            return compConfig.GetCompilerInfoFromLanguage("c#"); 
        } 

        internal static CodeSubDirectoriesCollection GetCodeSubDirectories() { 
            // Get the  config object
            CompilationSection config = RuntimeConfig.GetAppConfig().Compilation;

            CodeSubDirectoriesCollection codeSubDirectories = config.CodeSubDirectories; 

            // Make sure the config data is valid 
            if (codeSubDirectories != null) { 
                codeSubDirectories.EnsureRuntimeValidation();
            } 

            return codeSubDirectories;
        }
 
        internal static long GetRecompilationHash(CompilationSection ps)
        { 
            HashCodeCombiner recompilationHash = new HashCodeCombiner(); 
            AssemblyCollection assemblies;
            BuildProviderCollection builders; 
            CodeSubDirectoriesCollection codeSubDirs;

            // Combine items from Compilation section
            recompilationHash.AddObject(ps.Debug); 
            recompilationHash.AddObject(ps.Strict);
            recompilationHash.AddObject(ps.Explicit); 
            recompilationHash.AddObject(ps.Batch); 
            recompilationHash.AddObject(ps.OptimizeCompilations);
            recompilationHash.AddObject(ps.BatchTimeout); 
            recompilationHash.AddObject(ps.MaxBatchGeneratedFileSize);
            recompilationHash.AddObject(ps.MaxBatchSize);
            recompilationHash.AddObject(ps.NumRecompilesBeforeAppRestart);
            recompilationHash.AddObject(ps.DefaultLanguage); 
            recompilationHash.AddObject(ps.UrlLinePragmas);
            if (ps.AssemblyPostProcessorTypeInternal != null) { 
                recompilationHash.AddObject(ps.AssemblyPostProcessorTypeInternal.FullName); 
            }
 
            // Combine items from Compilers collection
            foreach (Compiler compiler in ps.Compilers) {
                recompilationHash.AddObject(compiler.Language);
                recompilationHash.AddObject(compiler.Extension); 
                recompilationHash.AddObject(compiler.Type);
                recompilationHash.AddObject(compiler.WarningLevel); 
                recompilationHash.AddObject(compiler.CompilerOptions); 
            }
 
            // Combine items from  section
            foreach (System.Web.Configuration.ExpressionBuilder eb in ps.ExpressionBuilders) {
                recompilationHash.AddObject(eb.ExpressionPrefix);
                recompilationHash.AddObject(eb.Type); 
            }
 
            // Combine items from the Assembly collection 
            assemblies = ps.Assemblies;
 
            if (assemblies.Count == 0) {
                recompilationHash.AddObject("__clearassemblies");
            }
            else { 
                foreach (AssemblyInfo ai in assemblies) {
                    recompilationHash.AddObject(ai.Assembly); 
                } 
            }
 
            // Combine items from the Builders Collection
            builders = ps.BuildProviders;

            if (builders.Count == 0) { 
                recompilationHash.AddObject("__clearbuildproviders");
            } 
            else { 
                foreach (System.Web.Configuration.BuildProvider bp in builders) {
                    recompilationHash.AddObject(bp.Type); 
                    recompilationHash.AddObject(bp.Extension);
                }
            }
 
            codeSubDirs = ps.CodeSubDirectories;
            if (codeSubDirs.Count == 0) { 
                recompilationHash.AddObject("__clearcodesubdirs"); 
            }
            else { 
                foreach (CodeSubDirectory csd in codeSubDirs) {
                    recompilationHash.AddObject(csd.DirectoryName);
                }
            } 

            // Make sure the  section is hashed properly. 
            CompilerInfo[] compilerInfoArray = CodeDomProvider.GetAllCompilerInfo(); 
            if (compilerInfoArray != null) {
                foreach (CompilerInfo info in compilerInfoArray) { 
                    // Ignore it if the type is not valid.
                    if (!info.IsCodeDomProviderTypeValid) {
                        continue;
                    } 

                    CompilerParameters parameters = info.CreateDefaultCompilerParameters(); 
                    string option = parameters.CompilerOptions; 
                    if (!String.IsNullOrEmpty(option)) {
                        Type type = info.CodeDomProviderType; 
                        if (type != null) {
                            recompilationHash.AddObject(type.FullName);
                        }
                        // compilerOptions need to be hashed. 
                        recompilationHash.AddObject(option);
                    } 
 
                    // DevDiv 62998
                    // The tag providerOption needs to be added to the hash, 
                    // as the user could switch between v2 and v3.5.
                    if (info.CodeDomProviderType == null)
                        continue;
 
                    // Add a hash for each providerOption added, specific for each codeDomProvider, so that
                    // if some codedom setting has changed, we know we have to recompile. 
                    System.Collections.Generic.IDictionary providerOptions = GetProviderOptions(info); 
                    if (providerOptions != null && providerOptions.Count > 0) {
                        string codeDomProviderType = info.CodeDomProviderType.FullName; 
                        foreach (string key in providerOptions.Keys) {
                            string value = providerOptions[key];
                            recompilationHash.AddObject(codeDomProviderType + ":" +  key + "=" + value);
                        } 
                    }
                } 
            } 

            return recompilationHash.CombinedHash; 
        }


        /* 
         * Simple wrapper to get the Assemblies
         */ 
        internal static AssemblyCollection GetAssembliesForAppLevel() { 
            // Get the CompilationSection object for the passed in config path
            CompilationSection compilationConfiguration = RuntimeConfig.GetAppConfig().Compilation; 
            return compilationConfiguration.Assemblies;
        }

        /* 
         * Look for a type by name in a collection of assemblies.  If it exists in multiple assemblies,
         * throw an error. 
         */ 
        // Assert reflection in order to call assembly.GetType()
        [ReflectionPermission(SecurityAction.Assert, Flags=ReflectionPermissionFlag.MemberAccess)] 
        internal static Type GetTypeFromAssemblies(AssemblyCollection assembliesCollection, string typeName, bool ignoreCase) {
            if (assembliesCollection == null)
                return null;
 
            Type type = null;
 
            foreach (AssemblyInfo info in assembliesCollection) { 
                Assembly[] assemblies = info.AssemblyInternal;
 
                for (int i = 0; i < assemblies.Length; i++) {
                    Assembly assembly = assemblies[i];
                    Type t = assembly.GetType(typeName, false /*throwOnError*/, ignoreCase);
 
                    if (t == null)
                        continue; 
 
                    // If we had already found a different one, it's an ambiguous type reference
                    if (type != null && t != type) { 
                        throw new HttpException(SR.GetString(
                            SR.Ambiguous_type, typeName,
                            Util.GetAssemblySafePathFromType(type), Util.GetAssemblySafePathFromType(t)));
                    } 

                    // Keep track of it 
                    type = t; 
                }
            } 

            return type;
        }
 

        /* 
         * Return a file provider Type that an extension maps to. 
         */
        internal static Type GetBuildProviderTypeFromExtension(VirtualPath configPath, string extension, 
            BuildProviderAppliesTo neededFor, bool failIfUnknown) {

            // Get the  config object
            CompilationSection config = RuntimeConfig.GetConfig(configPath).Compilation; 

            return GetBuildProviderTypeFromExtension(config, extension, neededFor, failIfUnknown); 
        } 

        internal static Type GetBuildProviderTypeFromExtension(CompilationSection config, string extension, 
            BuildProviderAppliesTo neededFor, bool failIfUnknown) {

            System.Web.Configuration.BuildProvider entry = (System.Web.Configuration.BuildProvider) config.BuildProviders[extension];
 
            Type buildProviderType = null;
            // Never return an IgnoreFileBuildProvider/ForceCopyBuildProvider, since it's just a marker 
            if (entry != null && 
                entry.TypeInternal != typeof(IgnoreFileBuildProvider) &&
                entry.TypeInternal != typeof(ForceCopyBuildProvider)) { 
                buildProviderType = entry.TypeInternal;
            }

            // In updatable precomp mode, only aspx/ascx/master web files need processing.  Ignore the rest. 
            if (neededFor == BuildProviderAppliesTo.Web &&
                BuildManager.PrecompilingForUpdatableDeployment && 
                !typeof(BaseTemplateBuildProvider).IsAssignableFrom(buildProviderType)) { 
                buildProviderType = null;
            } 

            if (buildProviderType != null) {
                // Only return it if it applies to what it's needed for
                if ((neededFor & entry.AppliesToInternal) != 0) 
                    return buildProviderType;
            } 
            // If the extension is registered as a compiler extension, use 
            // a SourceFileBuildProvider to handle it (not supported in Resources directory)
            else if (neededFor != BuildProviderAppliesTo.Resources && 
                config.GetCompilerInfoFromExtension(extension, false /*throwOnFail*/) != null) {
                return typeof(SourceFileBuildProvider);
            }
 
            if (failIfUnknown) {
                throw new HttpException( SR.GetString( 
                    SR.Unknown_buildprovider_extension, extension, neededFor.ToString())); 
            }
 
            return null;
        }

        internal static void CheckCompilerOptionsAllowed(string compilerOptions, bool config, string file, int line) { 

            // If it's empty, we never block it 
            if (String.IsNullOrEmpty(compilerOptions)) 
                return;
 
            // Only allow the use of compilerOptions when we have UnmanagedCode access (ASURT 73678)
            if (!HttpRuntime.HasUnmanagedPermission()) {
                string errorString = SR.GetString(SR.Insufficient_trust_for_attribute, "compilerOptions");
 
                if (config)
                    throw new ConfigurationErrorsException(errorString, file, line); 
                else 
                    throw new HttpException(errorString);
            } 
        }

        // This is used to determine what files need to be copied, and what stub files
        // need to be created during deployment precompilation. 
        // Note: createStub only applies if the method returns false.
        internal static bool NeedToCopyFile(VirtualPath virtualPath, bool updatable, out bool createStub) { 
 
            createStub = false;
 
            // Get the  config object
            CompilationSection config = RuntimeConfig.GetConfig(virtualPath).Compilation;

            string extension = virtualPath.Extension; 

            System.Web.Configuration.BuildProvider entry = (System.Web.Configuration.BuildProvider) config.BuildProviders[extension]; 
 
            if (entry != null) {
                // We only care about 'web' providers.  Everything else we treat as static 
                if ((BuildProviderAppliesTo.Web & entry.AppliesToInternal) == 0)
                    return true;

                // If the provider is a ForceCopyBuildProvider, treat as static 
                if (entry.TypeInternal == typeof(ForceCopyBuildProvider))
                    return true; 
 
                // During updatable precomp, everything needs to be copied over.  However,
                // aspx files that use code beside will later be overwritten by modified 
                // versions (see TemplateParser.CreateModifiedMainDirectiveFileIfNeeded)
                if (entry.TypeInternal != typeof(IgnoreFileBuildProvider) &&
                    BuildManager.PrecompilingForUpdatableDeployment) {
                    return true; 
                }
 
                // There is a real provider, so don't copy the file.  We also need to determine whether 
                // a stub file needs to be created.
 
                createStub = true;

                // Skip the stub file for some non-requestable types
                if (entry.TypeInternal == typeof(UserControlBuildProvider) || 
                    entry.TypeInternal == typeof(MasterPageBuildProvider) ||
                    entry.TypeInternal == typeof(IgnoreFileBuildProvider)) { 
                    createStub = false; 
                }
 
                return false;
            }

            // If the extension is registered as a compiler extension, don't copy 
            if (config.GetCompilerInfoFromExtension(extension, false /*throwOnFail*/) != null) {
                return false; 
            } 

            // Skip the copying for asax and skin files, which are not static even though they 
            // don't have a registered BuildProvider (but don't skip .skin files during
            // updatable precomp).
            //
            if (StringUtil.EqualsIgnoreCase(extension, ".asax")) 
                return false;
            if (!updatable && StringUtil.EqualsIgnoreCase(extension, ThemeDirectoryCompiler.skinExtension)) 
                return false; 

            // 
            // If there is no BuildProvider registered, it's a static file, and should be copied
            //

            return true; 
        }
 
        internal static Type LoadTypeWithChecks(string typeName, Type requiredBaseType, Type requiredBaseType2, ConfigurationElement elem, string propertyName) { 
            Type t = ConfigUtil.GetType(typeName, propertyName, elem);
 
            if (requiredBaseType2 == null) {
                ConfigUtil.CheckAssignableType(requiredBaseType, t, elem, propertyName);
            }
            else { 
                ConfigUtil.CheckAssignableType(requiredBaseType, requiredBaseType2, t, elem, propertyName);
            } 
 
            return t;
        } 

        // Devdiv Bug 57600
        // We need to use the constructor with ProviderOptions to get the v3.5 compiler that was possibly set in config.
        // We first check if there is any providerOptions and invoke the constructor if so. 
        // Otherwise, we fall back to the default constructor.
        internal static CodeDomProvider CreateCodeDomProvider(Type codeDomProviderType) { 
            CodeDomProvider codeDomProvider = CreateCodeDomProviderWithPropertyOptions(codeDomProviderType); 
            if (codeDomProvider != null)
                return codeDomProvider; 
            return (CodeDomProvider)Activator.CreateInstance(codeDomProviderType);
        }

        internal static CodeDomProvider CreateCodeDomProviderNonPublic(Type codeDomProviderType) { 
            CodeDomProvider codeDomProvider = CreateCodeDomProviderWithPropertyOptions(codeDomProviderType);
            if (codeDomProvider != null) 
                return codeDomProvider; 
            return (CodeDomProvider)HttpRuntime.CreateNonPublicInstance(codeDomProviderType);
        } 

        [ReflectionPermission(SecurityAction.Assert, Unrestricted = true)]
        private static CodeDomProvider CreateCodeDomProviderWithPropertyOptions(Type codeDomProviderType) {
            // The following resembles the code in System.CodeDom.CompilerInfo.CreateProvider 
            System.Collections.Generic.IDictionary providerOptions = GetProviderOptions(codeDomProviderType);
            if (providerOptions != null && providerOptions.Count > 0) { 
                Debug.Assert(codeDomProviderType != null, "codeDomProviderType should not be null"); 
                ConstructorInfo ci = codeDomProviderType.GetConstructor(new Type[] { typeof(System.Collections.Generic.IDictionary) });
                if (ci != null) { 
                    return (CodeDomProvider)ci.Invoke(new object[] { providerOptions });
                }
            }
            return null; 
        }
 
        [ReflectionPermission(SecurityAction.Assert, Unrestricted = true)] 
        internal static System.Collections.Generic.IDictionary GetProviderOptions(Type codeDomProviderType) {
            // Using reflection to get the property for the time being. 
            // This could simply return CompilerInfo.PropertyOptions if it goes public in future.
            CodeDomProvider provider = (CodeDomProvider) Activator.CreateInstance(codeDomProviderType);
            if (CodeDomProvider.IsDefinedExtension(provider.FileExtension)) {
                CompilerInfo ci = CodeDomProvider.GetCompilerInfo(CodeDomProvider.GetLanguageFromExtension(provider.FileExtension)); 
                return GetProviderOptions(ci);
            } 
            return null; 
        }
 
        [ReflectionPermission(SecurityAction.Assert, Unrestricted = true)]
        private static System.Collections.Generic.IDictionary GetProviderOptions(CompilerInfo ci) {
            Debug.Assert(ci != null, "CompilerInfo ci should not be null");
            PropertyInfo pi = ci.GetType().GetProperty("ProviderOptions", 
                BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.Instance);
            if (pi != null) 
                return (System.Collections.Generic.IDictionary)pi.GetValue(ci, null); 
            return null;
        } 

        // This returns true only if the version is v3.5
        internal static bool IsCompilerVersion35(Type codeDomProviderType) {
            System.Collections.Generic.IDictionary providerOptions = CompilationUtil.GetProviderOptions(codeDomProviderType); 

            // If providerOptions is available, try processing it. 
            if (providerOptions != null) { 
                string version;
                if (providerOptions.TryGetValue("CompilerVersion", out version)) { 
                    // If providerOptions contains the CompilerVersion key, it has to be either "v2.0" or "v3.5"
                    if (version == "v2.0")
                        return false;
                    else if (version == "v3.5") 
                        return true;
 
                    // If it is not v2.0 or v3.5, we throw an exception. 
                    throw new ConfigurationException(SR.GetString(SR.Invalid_attribute_value, version, CodeDomProviderOptionPath + "CompilerVersion"));
                } 
            }

            // If providerOptions is null, default to v2.0.
            // Or if providerOptions does not contain CompilerVersion, default to v2.0. 
            return false;
        } 
    } 
}
 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK