Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/Configuration/GlobalizationSection.cs

@@ -0,0 +1,344 @@
+//------------------------------------------------------------------------------
+// <copyright file="GlobalizationSection.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+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.Threading;
+    using System.Globalization;
+    using System.Web.Util;
+    using System.Security.Permissions;
+
+    /* 
+        <!--
+        globalization Attributes:
+          requestEncoding="[Encoding value]" - Encoding to use for request
+          responseEncoding="[Encoding value]" - Encoding to use for response
+          enableBestFitResponseEncoding="[true|false]" - Enable best fit character encoding for response
+          responseHeaderEncoding="[Encoding value]" - Encoding to use for response headers (default is utf-8)
+          fileEncoding="[Encoding value]" - Encoding to use for files
+          culture="[Culture]" - default Thread.CurrentCulture
+          uiCulture="[Culture]" - default Thread.CurrentUICulture
+          resourceProviderFactoryType="[type]"
+        -->
+        <globalization
+                requestEncoding="utf-8"
+                responseEncoding="utf-8"
+        />
+
+    */
+
+    public sealed class GlobalizationSection : ConfigurationSection {
+        private static ConfigurationPropertyCollection _properties;
+        private static readonly ConfigurationProperty _propRequestEncoding =
+            new ConfigurationProperty("requestEncoding", typeof(string), Encoding.UTF8.WebName, ConfigurationPropertyOptions.None);
+        private static readonly ConfigurationProperty _propResponseEncoding =
+            new ConfigurationProperty("responseEncoding", typeof(string), Encoding.UTF8.WebName, ConfigurationPropertyOptions.None);
+        private static readonly ConfigurationProperty _propFileEncoding =
+            new ConfigurationProperty("fileEncoding", typeof(string), String.Empty, ConfigurationPropertyOptions.None);
+        private static readonly ConfigurationProperty _propCulture =
+            new ConfigurationProperty("culture", typeof(string), String.Empty, ConfigurationPropertyOptions.None);
+        private static readonly ConfigurationProperty _propUICulture =
+            new ConfigurationProperty("uiCulture", typeof(string), String.Empty, ConfigurationPropertyOptions.None);
+        private static readonly ConfigurationProperty _propEnableClientBasedCulture =
+            new ConfigurationProperty("enableClientBasedCulture", typeof(bool), false, ConfigurationPropertyOptions.None);
+        private static readonly ConfigurationProperty _propResponseHeaderEncoding =
+            new ConfigurationProperty("responseHeaderEncoding", typeof(string), Encoding.UTF8.WebName, ConfigurationPropertyOptions.None);
+        private static readonly ConfigurationProperty _propResourceProviderFactoryType =
+            new ConfigurationProperty("resourceProviderFactoryType", typeof(string), String.Empty, ConfigurationPropertyOptions.None);
+        private static readonly ConfigurationProperty _propEnableBestFitResponseEncoding =
+            new ConfigurationProperty("enableBestFitResponseEncoding", typeof(bool), false, ConfigurationPropertyOptions.None);
+
+        private Encoding responseEncodingCache = null;
+        private Encoding responseHeaderEncodingCache = null;
+        private Encoding requestEncodingCache = null;
+        private Encoding fileEncodingCache = null;
+
+        private String cultureCache = null;
+        private String uiCultureCache = null;
+        private Type _resourceProviderFactoryType;
+
+        static GlobalizationSection() {
+            // Property initialization
+            _properties = new ConfigurationPropertyCollection();
+            _properties.Add(_propRequestEncoding);
+            _properties.Add(_propResponseEncoding);
+            _properties.Add(_propFileEncoding);
+            _properties.Add(_propCulture);
+            _properties.Add(_propUICulture);
+            _properties.Add(_propEnableClientBasedCulture);
+            _properties.Add(_propResponseHeaderEncoding);
+            _properties.Add(_propResourceProviderFactoryType);
+            _properties.Add(_propEnableBestFitResponseEncoding);
+        }
+
+        public GlobalizationSection() {
+        }
+
+        protected override ConfigurationPropertyCollection Properties {
+            get {
+                return _properties;
+            }
+        }
+
+        [ConfigurationProperty("requestEncoding", DefaultValue = "utf-8")]
+        public Encoding RequestEncoding {
+            get {
+                if (requestEncodingCache == null) {
+                    requestEncodingCache = Encoding.UTF8;
+                }
+                return requestEncodingCache;
+            }
+            set {
+                if (value != null) {
+                    base[_propRequestEncoding] = value.WebName;
+                    requestEncodingCache = value;
+                }
+                else {
+                    base[_propRequestEncoding] = value;
+                    requestEncodingCache = Encoding.UTF8;
+                }
+            }
+        }
+
+        [ConfigurationProperty("responseEncoding", DefaultValue = "utf-8")]
+        public Encoding ResponseEncoding {
+            get {
+                if (responseEncodingCache == null)
+                    responseEncodingCache = Encoding.UTF8;
+                return responseEncodingCache;
+            }
+            set {
+                if (value != null) {
+                    base[_propResponseEncoding] = value.WebName;
+                    responseEncodingCache = value;
+                }
+                else {
+                    base[_propResponseEncoding] = value;
+                    responseEncodingCache = Encoding.UTF8;
+                }
+            }
+        }
+
+        [ConfigurationProperty("responseHeaderEncoding", DefaultValue = "utf-8")]
+        public Encoding ResponseHeaderEncoding {
+            get {
+                if (responseHeaderEncodingCache == null) {
+                    responseHeaderEncodingCache = Encoding.UTF8;
+                }
+                return responseHeaderEncodingCache;
+            }
+            set {
+                if (value != null) {
+                    base[_propResponseHeaderEncoding] = value.WebName;
+                    responseHeaderEncodingCache = value;
+                }
+                else {
+                    base[_propResponseHeaderEncoding] = value;
+                    responseHeaderEncodingCache = Encoding.UTF8;
+                }
+            }
+        }
+
+        [ConfigurationProperty("fileEncoding")]
+        public Encoding FileEncoding {
+            get {
+                if (fileEncodingCache == null) {
+                    fileEncodingCache = Encoding.Default;
+                }
+                return fileEncodingCache;
+            }
+            set {
+                if (value != null) {
+                    base[_propFileEncoding] = value.WebName;
+                    fileEncodingCache = value;
+                }
+                else {
+                    base[_propFileEncoding] = value;
+                    fileEncodingCache = Encoding.Default;
+                }
+            }
+        }
+
+        [ConfigurationProperty("culture", DefaultValue = "")]
+        public string Culture {
+            get {
+                if (cultureCache == null) {
+                    cultureCache = (string)base[_propCulture];
+                }
+                return cultureCache;
+            }
+            set {
+                base[_propCulture] = value;
+                cultureCache = value;
+            }
+        }
+
+        [ConfigurationProperty("uiCulture", DefaultValue = "")]
+        public string UICulture {
+            get {
+                if (uiCultureCache == null) {
+                    uiCultureCache = (string)base[_propUICulture];
+                }
+                return uiCultureCache;
+            }
+            set {
+                base[_propUICulture] = value;
+                uiCultureCache = value;
+            }
+        }
+
+        [ConfigurationProperty("enableClientBasedCulture", DefaultValue = false)]
+        public bool EnableClientBasedCulture {
+            get {
+                return (bool)base[_propEnableClientBasedCulture];
+            }
+            set {
+                base[_propEnableClientBasedCulture] = value;
+            }
+        }
+
+        [ConfigurationProperty("resourceProviderFactoryType", DefaultValue = "")]
+        public string ResourceProviderFactoryType {
+            get {
+                return (string)base[_propResourceProviderFactoryType];
+            }
+            set {
+                base[_propResourceProviderFactoryType] = value;
+            }
+        }
+
+        [ConfigurationProperty("enableBestFitResponseEncoding", DefaultValue = false)]
+        public bool EnableBestFitResponseEncoding {
+            get {
+                return (bool)base[_propEnableBestFitResponseEncoding];
+            }
+            set {
+                base[_propEnableBestFitResponseEncoding] = value;
+            }
+        }
+
+        internal Type ResourceProviderFactoryTypeInternal {
+            get {
+                if (_resourceProviderFactoryType == null && !String.IsNullOrEmpty(ResourceProviderFactoryType)) {
+                    lock (this) {
+                        if (_resourceProviderFactoryType == null) {
+                            Type resourceProviderFactoryType = ConfigUtil.GetType(ResourceProviderFactoryType, "resourceProviderFactoryType", this);
+                            ConfigUtil.CheckBaseType(typeof(System.Web.Compilation.ResourceProviderFactory), resourceProviderFactoryType, "resourceProviderFactoryType", this);
+                            _resourceProviderFactoryType = resourceProviderFactoryType;
+                        }
+                    }
+                }
+
+                return _resourceProviderFactoryType;
+            }
+        }
+
+        private void CheckCulture(string configCulture) {
+            if (StringUtil.EqualsIgnoreCase(configCulture, HttpApplication.AutoCulture)) {
+                return;
+            }
+            else if (StringUtil.StringStartsWithIgnoreCase(configCulture, HttpApplication.AutoCulture)) {
+                // This will throw if bad
+                CultureInfo dummyCultureInfo = new CultureInfo(configCulture.Substring(5));
+                return;
+            }
+            // This will throw if bad
+            new CultureInfo(configCulture);
+        }
+
+        protected override void PreSerialize(XmlWriter writer) {
+            PostDeserialize();
+        }
+
+        protected override void PostDeserialize() {
+            ConfigurationPropertyCollection props = Properties;
+
+            // Need to check that the encodings provided are valid here
+            ConfigurationProperty errorProperty = null;
+            int errorLine = Int32.MaxValue;
+
+            try {
+                if (!String.IsNullOrEmpty((string)base[_propResponseEncoding]))
+                    responseEncodingCache = (Encoding)Encoding.GetEncoding((string)base[_propResponseEncoding]);
+            }
+            catch {
+                errorProperty = _propResponseEncoding;
+                errorLine = ElementInformation.Properties[errorProperty.Name].LineNumber;
+            }
+
+            try {
+                if (!String.IsNullOrEmpty((string)base[_propResponseHeaderEncoding])) {
+                    responseHeaderEncodingCache = (Encoding)Encoding.GetEncoding((string)base[_propResponseHeaderEncoding]);
+                }
+            }
+            catch {
+                if (errorLine > ElementInformation.Properties[_propResponseHeaderEncoding.Name].LineNumber) {
+                    errorProperty = _propResponseHeaderEncoding;
+                    errorLine = ElementInformation.Properties[errorProperty.Name].LineNumber;
+                }
+            }
+
+            try {
+                if (!String.IsNullOrEmpty((string)base[_propRequestEncoding])) {
+                    requestEncodingCache = (Encoding)Encoding.GetEncoding((string)base[_propRequestEncoding]);
+                }
+            }
+            catch {
+                if (errorLine > ElementInformation.Properties[_propRequestEncoding.Name].LineNumber) {
+                    errorProperty = _propRequestEncoding;
+                    errorLine = ElementInformation.Properties[errorProperty.Name].LineNumber;
+                }
+            }
+
+            try {
+                if (!String.IsNullOrEmpty((string)base[_propFileEncoding])) {
+                    fileEncodingCache = (Encoding)Encoding.GetEncoding((string)base[_propFileEncoding]);
+                }
+            }
+            catch {
+                if (errorLine > ElementInformation.Properties[_propFileEncoding.Name].LineNumber) {
+                    errorProperty = _propFileEncoding;
+                    errorLine = ElementInformation.Properties[errorProperty.Name].LineNumber;
+                }
+            }
+            try {
+                if (!String.IsNullOrEmpty((string)base[_propCulture])) {
+                    CheckCulture((string)base[_propCulture]);
+                }
+            }
+            catch {
+                if (errorLine > ElementInformation.Properties[_propCulture.Name].LineNumber) {
+                    errorProperty = _propCulture;
+                    errorLine = ElementInformation.Properties[_propCulture.Name].LineNumber;
+                }
+            }
+
+            try {
+                if (!String.IsNullOrEmpty((string)base[_propUICulture])) {
+                    CheckCulture((string)base[_propUICulture]);
+                }
+            }
+            catch {
+                if (errorLine > ElementInformation.Properties[_propUICulture.Name].LineNumber) {
+                    errorProperty = _propUICulture;
+                    errorLine = ElementInformation.Properties[_propUICulture.Name].LineNumber;
+                }
+            }
+
+            if (errorProperty != null) {
+                throw new ConfigurationErrorsException(SR.GetString(SR.Invalid_value_for_globalization_attr, errorProperty.Name),
+                    ElementInformation.Properties[errorProperty.Name].Source, ElementInformation.Properties[errorProperty.Name].LineNumber);
+
+            }
+        }
+    }
+}