345 lines
14 KiB
C#
345 lines
14 KiB
C#
//------------------------------------------------------------------------------
|
|
// <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);
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|