RuntimeConfig.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / Configuration / RuntimeConfig.cs / 1305376 / RuntimeConfig.cs

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

using System.Collections; 
using System.Configuration; 
using System.Configuration.Internal;
using System.Security; 
using System.Security.Permissions;
using System.Web;
using System.Web.Util;
using System.Web.Hosting; 
using System.Web.Configuration;
 
namespace System.Web.Configuration { 

    // 
    // Internal, read-only access to configuration settings.
    //
    internal class RuntimeConfig {
        // 
        // GetConfig() - get configuration appropriate for the current thread.
        // 
        // Looks up the HttpContext on the current thread if it is available, 
        // otherwise it uses the config at the app path.
        // 
        // Use GetConfig(context) if a context is available, as it will avoid
        // the lookup for contxt on the current thread.
        //
        // For config derived from ConfigurationSection, this will either 
        // return a non-null object or throw an exception.
        // 
        // For config implemented with IConfigurationSectionHandler, this 
        // may return null, non-null, or throw an exception.
        // 
        static internal RuntimeConfig GetConfig() {
            if (!HttpConfigurationSystem.UseHttpConfigurationSystem)  {
                return GetClientRuntimeConfig();
            } 

            HttpContext context = HttpContext.Current; 
            if (context != null) { 
                return GetConfig(context);
            } 
            else {
                return GetAppConfig();
            }
        } 

        // 
        // GetConfig(context) - gets configuration appropriate for the HttpContext. 
        // The most efficient way to get config.
        // 
        // For config derived from ConfigurationSection, this will either
        // return a non-null object or throw an exception.
        //
        // For config implemented with IConfigurationSectionHandler, this 
        // may return null, non-null, or throw an exception.
        // 
        [System.Runtime.TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")] 
        static internal RuntimeConfig GetConfig(HttpContext context) {
            if (!HttpConfigurationSystem.UseHttpConfigurationSystem)  { 
                return GetClientRuntimeConfig();
            }

            return context.GetRuntimeConfig(); 
        }
 
        // 
        // GetConfig(context, path) - returns the config at 'path'.
        // 
        // This method is more efficient than not using context, as
        // the config cached in the context is used if it matches the
        // context path.
        // 
        // For config derived from ConfigurationSection, this will either
        // return a non-null object or throw an exception. 
        // 
        // For config implemented with IConfigurationSectionHandler, this
        // may return null, non-null, or throw an exception. 
        //
        static internal RuntimeConfig GetConfig(HttpContext context, VirtualPath path) {
            if (!HttpConfigurationSystem.UseHttpConfigurationSystem)  {
                return GetClientRuntimeConfig(); 
            }
 
            return context.GetRuntimeConfig(path); 
        }
 
        //
        // GetConfig(path) - returns the config at 'path'.
        //
        // If 'path' is null, or is outside of the application path, then it 
        // returns the application config.
        // 
        // For efficientcy, use GetConfig(context) instead of this method 
        // where possible.
        // 
        // For config derived from ConfigurationSection, this will either
        // return a non-null object or throw an exception.
        //
        // For config implemented with IConfigurationSectionHandler, this 
        // may return null, non-null, or throw an exception.
        // 
        static internal RuntimeConfig GetConfig(string path) { 
            return GetConfig(VirtualPath.CreateNonRelativeAllowNull(path));
        } 

        static internal RuntimeConfig GetConfig(VirtualPath path) {
            if (!HttpConfigurationSystem.UseHttpConfigurationSystem) {
                return GetClientRuntimeConfig(); 
            }
 
            return CachedPathData.GetVirtualPathData(path, true).RuntimeConfig; 
        }
 
        //
        // GetAppConfig() - returns the application config.
        //
        // For config derived from ConfigurationSection, this will either 
        // return a non-null object or throw an exception.
        // 
        // For config implemented with IConfigurationSectionHandler, this 
        // may return null, non-null, or throw an exception.
        // 
        static internal RuntimeConfig GetAppConfig() {
            if (!HttpConfigurationSystem.UseHttpConfigurationSystem)  {
                return GetClientRuntimeConfig();
            } 

            return CachedPathData.GetApplicationPathData().RuntimeConfig; 
        } 

        // 
        // GetRootWebConfig() - returns the root web configuration.
        //
        // For config derived from ConfigurationSection, this will either
        // return a non-null object or throw an exception. 
        //
        // For config implemented with IConfigurationSectionHandler, this 
        // may return null, non-null, or throw an exception. 
        //
        static internal RuntimeConfig GetRootWebConfig() { 
            if (!HttpConfigurationSystem.UseHttpConfigurationSystem)  {
                return GetClientRuntimeConfig();
            }
 
            return CachedPathData.GetRootWebPathData().RuntimeConfig;
        } 
 
        //
        // GetMachineConfig() - returns the machine configuration. 
        //
        // For config derived from ConfigurationSection, this will either
        // return a non-null object or throw an exception.
        // 
        // For config implemented with IConfigurationSectionHandler, this
        // may return null, non-null, or throw an exception. 
        // 
        static internal RuntimeConfig GetMachineConfig() {
            if (!HttpConfigurationSystem.UseHttpConfigurationSystem)  { 
                return GetClientRuntimeConfig();
            }

            return CachedPathData.GetMachinePathData().RuntimeConfig; 
        }
 
        // 
        // GetLKGConfig(context) - gets the nearest configuration available.
        // 
        // This method is to be used in the few instances where we
        // cannot throw an exception if a config file has an error.
        //
        // This method will never throw an exception. If no config 
        // is available, a request for a section will return null.
        // 
        static internal RuntimeConfig GetLKGConfig(HttpContext context) { 
            RuntimeConfig config = null;
            bool success = false; 
            try {
                config = GetConfig(context);
                success = true;
            } 
            catch {
            } 
 
            if (!success) {
                config = GetLKGRuntimeConfig(context.Request.FilePathObject); 
            }

            return config.RuntimeConfigLKG;
        } 

        // 
        // GetAppLKGConfig(path) - gets the nearest configuration available, 
        // starting from the application path.
        // 
        // This method is to be used in the few instances where we
        // cannot throw an exception if a config file has an error.
        //
        // This method will never throw an exception. If no config 
        // is available, a request for a section will return null.
        // 
        static internal RuntimeConfig GetAppLKGConfig() { 
            RuntimeConfig config = null;
            bool success = false; 
            try {
                config = GetAppConfig();
                success = true;
            } 
            catch {
            } 
 

            if (!success) { 
                config = GetLKGRuntimeConfig(System.Web.Hosting.HostingEnvironment.ApplicationVirtualPathObject);
            }

            return config.RuntimeConfigLKG; 
        }
 
        // 
        // WHIDBEY sections
        // 

        internal ConnectionStringsSection ConnectionStrings {
            get {
                return (ConnectionStringsSection) GetSection("connectionStrings", typeof(ConnectionStringsSection), ResultsIndex.ConnectionStrings); 
            }
        } 
 
        internal System.Net.Configuration.SmtpSection Smtp {
            get { 
                return (System.Net.Configuration.SmtpSection) GetSection("system.net/mailSettings/smtp", typeof(System.Net.Configuration.SmtpSection));
            }
        }
 
        internal AnonymousIdentificationSection AnonymousIdentification {
            get { 
                return (AnonymousIdentificationSection) GetSection("system.web/anonymousIdentification", typeof(AnonymousIdentificationSection)); 
            }
        } 

        internal ProtocolsSection Protocols {
            get {
                return (ProtocolsSection) GetSection("system.web/protocols", typeof(ProtocolsSection)); 
            }
        } 
 
        internal AuthenticationSection Authentication {
            get { 
                return (AuthenticationSection) GetSection("system.web/authentication", typeof(AuthenticationSection), ResultsIndex.Authentication);
            }
        }
 
        internal AuthorizationSection Authorization {
            get { 
                return (AuthorizationSection) GetSection("system.web/authorization", typeof(AuthorizationSection), ResultsIndex.Authorization); 
            }
        } 

        // may return null
        internal HttpCapabilitiesDefaultProvider BrowserCaps {
            get { 
                return (HttpCapabilitiesDefaultProvider) GetHandlerSection("system.web/browserCaps", typeof(HttpCapabilitiesDefaultProvider), ResultsIndex.BrowserCaps);
            } 
        } 

        internal ClientTargetSection ClientTarget { 
            get {
                return (ClientTargetSection) GetSection("system.web/clientTarget", typeof(ClientTargetSection), ResultsIndex.ClientTarget);
            }
        } 

        internal CompilationSection Compilation { 
            get { 
                return (CompilationSection) GetSection("system.web/compilation", typeof(CompilationSection), ResultsIndex.Compilation);
            } 
        }

        internal CustomErrorsSection CustomErrors {
            get { 
                return (CustomErrorsSection) GetSection("system.web/customErrors", typeof(CustomErrorsSection));
            } 
        } 

        internal GlobalizationSection Globalization { 
            get {
                return (GlobalizationSection) GetSection("system.web/globalization", typeof(GlobalizationSection), ResultsIndex.Globalization);
            }
        } 

        internal DeploymentSection Deployment { 
            get { 
                return (DeploymentSection) GetSection("system.web/deployment", typeof(DeploymentSection));
            } 
        }

        internal FullTrustAssembliesSection FullTrustAssemblies {
            get { 
                return (FullTrustAssembliesSection)GetSection("system.web/fullTrustAssemblies", typeof(FullTrustAssembliesSection));
            } 
        } 

        internal HealthMonitoringSection HealthMonitoring { 
            get {
                return (HealthMonitoringSection) GetSection("system.web/healthMonitoring", typeof(HealthMonitoringSection));
            }
        } 

        internal HostingEnvironmentSection HostingEnvironment { 
            get { 
                return (HostingEnvironmentSection) GetSection("system.web/hostingEnvironment", typeof(HostingEnvironmentSection));
            } 
        }

        internal HttpCookiesSection HttpCookies {
            get { 
                return (HttpCookiesSection) GetSection("system.web/httpCookies", typeof(HttpCookiesSection), ResultsIndex.HttpCookies);
            } 
        } 

        internal HttpHandlersSection HttpHandlers { 
            get {
                return (HttpHandlersSection) GetSection("system.web/httpHandlers", typeof(HttpHandlersSection), ResultsIndex.HttpHandlers);
            }
        } 

        internal HttpModulesSection HttpModules { 
            get { 
                return (HttpModulesSection) GetSection("system.web/httpModules", typeof(HttpModulesSection), ResultsIndex.HttpModules);
            } 
        }

        internal HttpRuntimeSection HttpRuntime {
            get { 
                return (HttpRuntimeSection) GetSection("system.web/httpRuntime", typeof(HttpRuntimeSection), ResultsIndex.HttpRuntime);
            } 
        } 

        internal IdentitySection Identity { 
            get {
                return (IdentitySection) GetSection("system.web/identity", typeof(IdentitySection), ResultsIndex.Identity);
            }
        } 

        internal MachineKeySection MachineKey { 
            get { 
                return (MachineKeySection) GetSection("system.web/machineKey", typeof(MachineKeySection), ResultsIndex.MachineKey);
            } 
        }

        internal MembershipSection Membership {
            get { 
                return (MembershipSection) GetSection("system.web/membership", typeof(MembershipSection), ResultsIndex.Membership);
            } 
        } 

        internal PagesSection Pages { 
            [System.Runtime.TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
            get {
                return (PagesSection) GetSection("system.web/pages", typeof(PagesSection), ResultsIndex.Pages);
            } 
        }
 
        internal PartialTrustVisibleAssembliesSection PartialTrustVisibleAssemblies { 
            get
            { 
                return (PartialTrustVisibleAssembliesSection)GetSection("system.web/partialTrustVisibleAssemblies", typeof(PartialTrustVisibleAssembliesSection));
            }
        }
 
        internal ProcessModelSection ProcessModel {
            get { 
                return (ProcessModelSection) GetSection("system.web/processModel", typeof(ProcessModelSection)); 
            }
        } 

        internal ProfileSection Profile {
            get {
                return (ProfileSection) GetSection("system.web/profile", typeof(ProfileSection), ResultsIndex.Profile); 
            }
        } 
 
        internal RoleManagerSection RoleManager {
            get { 
                return (RoleManagerSection) GetSection("system.web/roleManager", typeof(RoleManagerSection));
            }
        }
 
        internal SecurityPolicySection SecurityPolicy {
            get { 
                return (SecurityPolicySection) GetSection("system.web/securityPolicy", typeof(SecurityPolicySection)); 
            }
        } 

        internal SessionPageStateSection SessionPageState {
            get {
                return (SessionPageStateSection) GetSection("system.web/sessionPageState", typeof(SessionPageStateSection), ResultsIndex.SessionPageState); 
            }
        } 
 
        internal SessionStateSection SessionState {
            get { 
                return (SessionStateSection) GetSection("system.web/sessionState", typeof(SessionStateSection));
            }
        }
 
        internal SiteMapSection SiteMap {
            get { 
                return (SiteMapSection) GetSection("system.web/siteMap", typeof(SiteMapSection)); 
            }
        } 

        internal TraceSection Trace {
            get {
                return (TraceSection) GetSection("system.web/trace", typeof(TraceSection)); 
            }
        } 
 
        internal TrustSection Trust {
            get { 
                return (TrustSection) GetSection("system.web/trust", typeof(TrustSection));
            }
        }
 
        internal UrlMappingsSection UrlMappings {
            get { 
                return (UrlMappingsSection) GetSection("system.web/urlMappings", typeof(UrlMappingsSection), ResultsIndex.UrlMappings); 
            }
        } 

        internal Hashtable WebControls {
            get {
                return (Hashtable)GetSection("system.web/webControls", typeof(Hashtable), ResultsIndex.WebControls); 
            }
        } 
 
        internal WebPartsSection WebParts {
            get { 
                return (WebPartsSection) GetSection("system.web/webParts", typeof(WebPartsSection), ResultsIndex.WebParts);
            }
        }
 
        internal XhtmlConformanceSection XhtmlConformance {
            get { 
                return (XhtmlConformanceSection) GetSection("system.web/xhtmlConformance", typeof(XhtmlConformanceSection), ResultsIndex.XhtmlConformance); 
            }
        } 

        internal CacheSection Cache {
            get {
                return (CacheSection) GetSection("system.web/caching/cache", typeof(CacheSection)); 
            }
        } 
 
        internal OutputCacheSection OutputCache {
            get { 
                return (OutputCacheSection) GetSection("system.web/caching/outputCache", typeof(OutputCacheSection), ResultsIndex.OutputCache);
            }
        }
 
        internal OutputCacheSettingsSection OutputCacheSettings {
            get { 
                return (OutputCacheSettingsSection) GetSection("system.web/caching/outputCacheSettings", typeof(OutputCacheSettingsSection), ResultsIndex.OutputCacheSettings); 
            }
        } 

        internal SqlCacheDependencySection SqlCacheDependency {
            get {
                return (SqlCacheDependencySection) GetSection("system.web/caching/sqlCacheDependency", typeof(SqlCacheDependencySection)); 
            }
        } 
 

        ////////////////////////////// 
        //
        // IMPLEMENTATION
        //
        ////////////////////////////// 

        // Wraps calls to RuntimeConfig.GetConfig() when 
        // the web config system is not being used. 
        private static RuntimeConfig    s_clientRuntimeConfig;
 
        // Wraps calls to RuntimeConfig.GetConfig() when
        // we must return null.
        private static RuntimeConfig    s_nullRuntimeConfig;
 
        // Wraps calls to RuntimeConfig.GetConfig() when
        // we must return an error because there was an 
        // unrecoverable error creating the config record. 
        private static RuntimeConfig    s_errorRuntimeConfig;
 
        // object used to indicate that result has not been evaluated
        private static object           s_unevaluatedResult;

        // Commonly used results on every request. We cache these by index 
        // into an array so we don't need to do hash table lookups,
        // type comparisons, and handle a demand for ConfigurationPermission 
        // to retreive the config. 
        internal enum ResultsIndex {
            // a valid index into the results array that is always unevaluated 
            UNUSED = 0,

            Authentication,
            Authorization, 
            BrowserCaps,
            ClientTarget, 
            Compilation, 
            ConnectionStrings,
            Globalization, 
            HttpCookies,
            HttpHandlers,
            HttpModules,
            HttpRuntime, 
            Identity,
            MachineKey, 
            Membership, 
            OutputCache,
            OutputCacheSettings, 
            Pages,
            Profile,
            SessionPageState,
            WebControls, 
            WebParts,
            UrlMappings, 
            XhtmlConformance, 

            // size of the results array, must be last in list 
            SIZE
        };

        // cached results 
        // Per-path caching for perf reason.  Available only to internal components.
        private object[]                _results; 
 
        // LKG config
        private RuntimeConfigLKG        _runtimeConfigLKG; 

        // for http configuration, the ConfigurationRecord on which we call GetConfig
        protected IInternalConfigRecord _configRecord;
 
        // classes implementing LKG may return null from GetSectionObject
        private bool                    _permitNull; 
 
        static RuntimeConfig() {
            s_unevaluatedResult = new object(); 

            // Ensure that we have an error config record available if we
            // get an unrecoverable error situation.
            GetErrorRuntimeConfig(); 
        }
 
        // ctor used by CachedPathData to wrap the ConfigurationRecord 
        internal RuntimeConfig(IInternalConfigRecord configRecord) : this(configRecord, false) {}
 
        protected RuntimeConfig(IInternalConfigRecord configRecord, bool permitNull) {
            _configRecord = configRecord;
            _permitNull = permitNull;
 
            // initialize results cache
            _results = new object[(int)ResultsIndex.SIZE]; 
            for (int i = 0; i < _results.Length; i++) { 
                _results[i] = s_unevaluatedResult;
            } 
        }

        private RuntimeConfigLKG RuntimeConfigLKG {
            get { 
                if (_runtimeConfigLKG == null) {
                    lock (this) { 
                        if (_runtimeConfigLKG == null) { 
                            _runtimeConfigLKG = new RuntimeConfigLKG(_configRecord);
                        } 
                    }
                }

                return _runtimeConfigLKG; 
            }
        } 
 
        internal IInternalConfigRecord ConfigRecord {
            get { 
                return _configRecord;
            }
        }
 
        // Create the single instance of the wrapper for ConfigurationManager configuration.
        static RuntimeConfig GetClientRuntimeConfig() { 
            if (s_clientRuntimeConfig == null) { 
                s_clientRuntimeConfig = new ClientRuntimeConfig();
            } 

            return s_clientRuntimeConfig;
        }
 
        // Create the single instance of the wrapper for null configuration.
        static RuntimeConfig GetNullRuntimeConfig() { 
            if (s_nullRuntimeConfig == null) { 
                s_nullRuntimeConfig = new NullRuntimeConfig();
            } 

            return s_nullRuntimeConfig;
        }
 
        // Create the single instance of the wrapper for error configuration.
        static internal RuntimeConfig GetErrorRuntimeConfig() { 
            if (s_errorRuntimeConfig == null) { 
                s_errorRuntimeConfig = new ErrorRuntimeConfig();
            } 

            return s_errorRuntimeConfig;
        }
 
        // Get the config object for a section
        [ConfigurationPermission(SecurityAction.Assert, Unrestricted=true)] 
        protected virtual object GetSectionObject(string sectionName) { 
            return _configRecord.GetSection(sectionName);
        } 


        //
        // Return a config implemented by IConfigurationHandler, 
        // and use the runtime cache to store it for quick retreival without
        // having to hit a config record and a demand for ConfigurationPermission. 
        // 
        private object GetHandlerSection(string sectionName, Type type, ResultsIndex index) {
            // check the results cache 
            object result = _results[(int)index];
            if (result != s_unevaluatedResult) {
                return result;
            } 

            // Get the configuration object. 
            // 
            // Note that it is legal for an IConfigurationSectionHandler implementation
            // to return null. 
            result = GetSectionObject(sectionName);

            // verify the object is of the expected type
            if (result != null && result.GetType() != type) { 
                throw new ConfigurationErrorsException(SR.GetString(SR.Config_unable_to_get_section, sectionName));
            } 
 
            // store into results cache
            if (index != ResultsIndex.UNUSED) { 
                _results[(int)index] = result;
            }

            return result; 
        }
 
        // 
        // Return a configuration section without checking the runtime cache.
        // 
        private object GetSection(string sectionName, Type type) {
            return GetSection(sectionName, type, ResultsIndex.UNUSED);
        }
 
        //
        // Return a configuration section, and use the runtime cache to store it for 
        // quick retreival without having to hit a config record and a demand for 
        // ConfigurationPermission.
        // 
        private object GetSection(string sectionName, Type type, ResultsIndex index) {
            // check the results cache
            object result = _results[(int)index];
            if (result != s_unevaluatedResult) { 
                return result;
            } 
 
            // get the configuration object
            result = GetSectionObject(sectionName); 
            if (result == null) {
                // A section implemented by ConfigurationSection may not return null,
                // but various error handling subclasses of RuntimeConfig may need it.
                // Throw an error if null is not permitted. 
                if (!_permitNull) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_unable_to_get_section, sectionName)); 
                } 
            }
            else { 
                // verify the object is of the expected type
                if (result.GetType() != type) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_unable_to_get_section, sectionName));
                } 
            }
 
            // store into results cache 
            if (index != ResultsIndex.UNUSED) {
                _results[(int)index] = result; 
            }

            return result;
        } 

        // 
        // There are extreme cases where we cannot even retreive the CachedPathData 
        // for a path - such as when MapPath deems the path to be suspicious.
        // In these cases, walk the hierarchy upwards until we are able to retreive 
        // a CachedPathData and its associated RuntimeConfig.
        //
        static private RuntimeConfig GetLKGRuntimeConfig(VirtualPath path) {
            try { 
                // Start with the parent of the path.
                path = path.Parent; 
            } 
            catch {
                path = System.Web.Hosting.HostingEnvironment.ApplicationVirtualPathObject; 
            }

            // Walk the path hierarchy until we can succesfully get a RuntimeConfig.
            while (path != null) { 
                try {
                    return GetConfig(path); 
                } 
                catch {
                    path = path.Parent; 
                }
            }

            try { 
                return GetRootWebConfig();
            } 
            catch { 
            }
 
            try {
                return GetMachineConfig();
            }
            catch { 
            }
 
            return GetNullRuntimeConfig(); 
        }
    } 
}

// 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