CustomErrorsSection.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / Configuration / CustomErrorsSection.cs / 1305376 / CustomErrorsSection.cs
                        
                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Web.Configuration { 
    using System; 
    using System.Xml;
    using System.Configuration; 
    using System.Collections.Specialized;
    using System.Collections;
    using System.IO;
    using System.Text; 
    using System.Globalization;
    using System.Web.Util; 
    using System.Web.Configuration; 
    using System.Security.Permissions;
 
    /* From Machine.Config
    
         
    */
    public sealed class CustomErrorsSection : ConfigurationSection { 
        private static ConfigurationPropertyCollection _properties; 

        private static readonly ConfigurationProperty _propDefaultRedirect = 
            new ConfigurationProperty("defaultRedirect",
                                        typeof(string),
                                        null,
                                        ConfigurationPropertyOptions.None); 

        private static readonly ConfigurationProperty _propRedirectMode = 
            new ConfigurationProperty("redirectMode", 
                                        typeof(CustomErrorsRedirectMode),
                                        CustomErrorsRedirectMode.ResponseRedirect, 
                                        ConfigurationPropertyOptions.None);

        private static readonly ConfigurationProperty _propMode =
            new ConfigurationProperty("mode", 
                                        typeof(CustomErrorsMode),
                                        CustomErrorsMode.RemoteOnly, 
                                        ConfigurationPropertyOptions.None); 

        private static readonly ConfigurationProperty _propErrors = 
            new ConfigurationProperty(null,
                                        typeof(CustomErrorCollection),
                                        null,
                                        ConfigurationPropertyOptions.IsDefaultCollection); 

        private string basepath = null; 
        private string _DefaultAbsolutePath = null; 
        private static CustomErrorsSection _default = null;
 
        static CustomErrorsSection() {
            // Property initialization
            _properties = new ConfigurationPropertyCollection();
            _properties.Add(_propDefaultRedirect); 
            _properties.Add(_propRedirectMode);
            _properties.Add(_propMode); 
            _properties.Add(_propErrors); 
        }
 
        public CustomErrorsSection() {
        }

        protected override ConfigurationPropertyCollection Properties { 
            get {
                return _properties; 
            } 
        }
 
        [ConfigurationProperty("defaultRedirect")]
        public string DefaultRedirect {
            get {
                return (string)base[_propDefaultRedirect]; 
            }
            set { 
                base[_propDefaultRedirect] = value; 
            }
        } 

        [ConfigurationProperty("redirectMode", DefaultValue = CustomErrorsRedirectMode.ResponseRedirect)]
        public CustomErrorsRedirectMode RedirectMode {
            get { 
                return (CustomErrorsRedirectMode)base[_propRedirectMode];
            } 
            set { 
                base[_propRedirectMode] = value;
            } 
        }

        [ConfigurationProperty("mode", DefaultValue = CustomErrorsMode.RemoteOnly)]
        public CustomErrorsMode Mode { 
            get {
                return (CustomErrorsMode)base[_propMode]; 
            } 
            set {
                base[_propMode] = value; 
            }
        }

        [ConfigurationProperty("", IsDefaultCollection = true)] 
        public CustomErrorCollection Errors {
            get { 
                return (CustomErrorCollection)base[_propErrors]; 
            }
        } 

        internal String DefaultAbsolutePath {
            get {
                if (_DefaultAbsolutePath == null) { 
                    _DefaultAbsolutePath = GetAbsoluteRedirect(DefaultRedirect, basepath);
                } 
 
                return _DefaultAbsolutePath;
            } 
        }

        internal String GetRedirectString(int code) {
            String r = null; 

            if (Errors != null) { 
                CustomError ce = Errors[(string)code.ToString(CultureInfo.InvariantCulture)]; 
                if (ce != null)
                    r = GetAbsoluteRedirect(ce.Redirect, basepath); 
            }

            if (r == null) {
                r = DefaultAbsolutePath; 
            }
 
            return r; 
        }
 
        protected override void Reset(ConfigurationElement parentElement) {
            base.Reset(parentElement);
            CustomErrorsSection parent = parentElement as CustomErrorsSection;
            if (parent != null) { 
                basepath = parent.basepath;
            } 
        } 

        protected override void DeserializeSection(XmlReader reader) { 
            WebContext context;

            base.DeserializeSection(reader);
 
            // Determine Web Context
            context = EvaluationContext.HostingContext as WebContext; 
 
            if (context != null) {
                basepath = UrlPath.AppendSlashToPathIfNeeded(context.Path); 
            }
        }
        //
        // helper to create absolute redirect 
        //
        internal static String GetAbsoluteRedirect(String path, String basePath) { 
            if (path != null && UrlPath.IsRelativeUrl(path)) { 
                if (String.IsNullOrEmpty(basePath))
                    basePath = "/"; 

                path = UrlPath.Combine(basePath, path);
            }
 
            return path;
        } 
 
        internal static CustomErrorsSection GetSettings(HttpContext context) {
            return GetSettings(context, false); 
        }

        internal static CustomErrorsSection GetSettings(HttpContext context, bool canThrow) {
            CustomErrorsSection ce = null; 
            RuntimeConfig runtimeConfig = null;
            if (canThrow) { 
                runtimeConfig = RuntimeConfig.GetConfig(context); 
                if (runtimeConfig != null) {
                    ce = runtimeConfig.CustomErrors; 
                }
            }
            else {
                runtimeConfig = RuntimeConfig.GetLKGConfig(context); 
                if (runtimeConfig != null) {
                    ce = runtimeConfig.CustomErrors; 
                } 
                if (ce == null) {
                    if (_default == null) { 
                        _default = new CustomErrorsSection();
                    }

                    ce = _default; 
                }
            } 
 
            return ce;
        } 

        internal bool CustomErrorsEnabled(HttpRequest request) {
            // This could throw if the config file is malformed, but we don't want
            // to throw from here, as it would mess up error handling 
            try {
                // Always turn of custom errors in retail deployment mode (DevDiv 36396) 
                if (DeploymentSection.RetailInternal) 
                    return true;
            } 
            catch { }

            switch (Mode) {
                case CustomErrorsMode.Off: 
                    return false;
 
                case CustomErrorsMode.On: 
                    return true;
 
                case CustomErrorsMode.RemoteOnly:
                    return (!request.IsLocal);

                default: 
                    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
CustomErrorsSection.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
