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