Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

520 lines
28 KiB
C#

//------------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
namespace System.Web.Services.Configuration {
using System;
using System.Collections;
using System.Collections.Generic;
using System.Configuration;
using System.Globalization;
using System.Security.Permissions;
using System.Threading;
using System.Web;
using System.Web.Services.Description;
using System.Web.Services.Discovery;
using System.Web.Services.Protocols;
using System.Xml.Serialization;
using System.Runtime.CompilerServices;
public sealed class WebServicesSection : ConfigurationSection {
public WebServicesSection() : base() {
this.properties.Add(this.conformanceWarnings);
this.properties.Add(this.protocols);
this.properties.Add(this.serviceDescriptionFormatExtensionTypes);
this.properties.Add(this.soapEnvelopeProcessing);
this.properties.Add(this.soapExtensionImporterTypes);
this.properties.Add(this.soapExtensionReflectorTypes);
this.properties.Add(this.soapExtensionTypes);
this.properties.Add(this.soapTransportImporterTypes);
this.properties.Add(this.wsdlHelpGenerator);
this.properties.Add(this.soapServerProtocolFactoryType);
this.properties.Add(this.diagnostics);
}
static object ClassSyncObject {
get {
if (classSyncObject == null) {
object o = new object();
Interlocked.CompareExchange(ref classSyncObject, o, null);
}
return classSyncObject;
}
}
[ConfigurationProperty("conformanceWarnings")]
public WsiProfilesElementCollection ConformanceWarnings {
get { return (WsiProfilesElementCollection)base[this.conformanceWarnings]; }
}
internal WsiProfiles EnabledConformanceWarnings {
get {
WsiProfiles retval = WsiProfiles.None;
foreach (WsiProfilesElement element in this.ConformanceWarnings) {
retval |= element.Name;
}
return retval;
}
}
public static WebServicesSection Current {
get {
WebServicesSection retval = null;
// check to see if we are running on the server without loading system.web.dll
if (Thread.GetDomain().GetData(".appDomain") != null) {
retval = GetConfigFromHttpContext();
}
if (retval == null) {
retval = (WebServicesSection)PrivilegedConfigurationManager.GetSection(WebServicesSection.SectionName);
}
return retval;
}
}
[ConfigurationPermission(SecurityAction.Assert, Unrestricted = true)]
[MethodImplAttribute(MethodImplOptions.NoInlining)]
static WebServicesSection GetConfigFromHttpContext() {
PartialTrustHelpers.FailIfInPartialTrustOutsideAspNet();
HttpContext context = HttpContext.Current;
if (context != null) {
return (WebServicesSection)context.GetSection(WebServicesSection.SectionName);
}
return null;
}
internal XmlSerializer DiscoveryDocumentSerializer {
get {
if (this.discoveryDocumentSerializer == null) {
lock (WebServicesSection.ClassSyncObject) {
if (this.discoveryDocumentSerializer == null) {
XmlAttributeOverrides attrOverrides = new XmlAttributeOverrides();
XmlAttributes attrs = new XmlAttributes();
foreach (Type discoveryReferenceType in this.DiscoveryReferenceTypes) {
object[] xmlElementAttribs = discoveryReferenceType.GetCustomAttributes(typeof(XmlRootAttribute), false);
if (xmlElementAttribs.Length == 0) {
throw new InvalidOperationException(Res.GetString(Res.WebMissingCustomAttribute, discoveryReferenceType.FullName, "XmlRoot"));
}
string name = ((XmlRootAttribute)xmlElementAttribs[0]).ElementName;
string ns = ((XmlRootAttribute)xmlElementAttribs[0]).Namespace;
XmlElementAttribute attr = new XmlElementAttribute(name, discoveryReferenceType);
attr.Namespace = ns;
attrs.XmlElements.Add(attr);
}
attrOverrides.Add(typeof(DiscoveryDocument), "References", attrs);
this.discoveryDocumentSerializer = new DiscoveryDocumentSerializer();
}
}
}
return discoveryDocumentSerializer;
}
}
internal Type[] DiscoveryReferenceTypes {
get { return this.discoveryReferenceTypes; }
}
public WebServiceProtocols EnabledProtocols {
get {
if (this.enabledProtocols == WebServiceProtocols.Unknown) {
lock (WebServicesSection.ClassSyncObject) {
if (this.enabledProtocols == WebServiceProtocols.Unknown) {
WebServiceProtocols temp = WebServiceProtocols.Unknown;
foreach (ProtocolElement element in this.Protocols) {
temp |= (WebServiceProtocols)element.Name;
}
this.enabledProtocols = temp;
}
}
}
return this.enabledProtocols;
}
}
internal Type[] GetAllFormatExtensionTypes() {
if (this.ServiceDescriptionFormatExtensionTypes.Count == 0) {
return this.defaultFormatTypes;
}
else {
Type[] formatTypes = new Type[defaultFormatTypes.Length + this.ServiceDescriptionFormatExtensionTypes.Count];
Array.Copy(defaultFormatTypes, formatTypes, defaultFormatTypes.Length);
for (int index = 0; index < this.ServiceDescriptionFormatExtensionTypes.Count; ++index) {
formatTypes[index + defaultFormatTypes.Length] = this.ServiceDescriptionFormatExtensionTypes[index].Type;
}
return formatTypes;
}
}
static XmlFormatExtensionPointAttribute GetExtensionPointAttribute(Type type) {
object[] attrs = type.GetCustomAttributes(typeof(XmlFormatExtensionPointAttribute), false);
if (attrs.Length == 0)
throw new ArgumentException(Res.GetString(Res.TheSyntaxOfTypeMayNotBeExtended1, type.FullName), "type");
return (XmlFormatExtensionPointAttribute)attrs[0];
}
[ConfigurationPermission(SecurityAction.Assert, Unrestricted = true)]
static public WebServicesSection GetSection(Configuration config) {
if (config == null) {
throw new ArgumentNullException("config");
}
return (WebServicesSection)config.GetSection(WebServicesSection.SectionName);
}
protected override void InitializeDefault() {
this.ConformanceWarnings.SetDefaults();
this.Protocols.SetDefaults();
// check to see if we are running on the server without loading system.web.dll
if (Thread.GetDomain().GetData(".appDomain") != null) {
this.WsdlHelpGenerator.SetDefaults();
}
this.SoapServerProtocolFactoryType.Type = typeof(SoapServerProtocolFactory);
}
internal static void LoadXmlFormatExtensions(Type[] extensionTypes, XmlAttributeOverrides overrides, XmlSerializerNamespaces namespaces) {
Hashtable table = new Hashtable();
table.Add(typeof(ServiceDescription), new XmlAttributes());
table.Add(typeof(Import), new XmlAttributes());
table.Add(typeof(Port), new XmlAttributes());
table.Add(typeof(Service), new XmlAttributes());
table.Add(typeof(FaultBinding), new XmlAttributes());
table.Add(typeof(InputBinding), new XmlAttributes());
table.Add(typeof(OutputBinding), new XmlAttributes());
table.Add(typeof(OperationBinding), new XmlAttributes());
table.Add(typeof(Binding), new XmlAttributes());
table.Add(typeof(OperationFault), new XmlAttributes());
table.Add(typeof(OperationInput), new XmlAttributes());
table.Add(typeof(OperationOutput), new XmlAttributes());
table.Add(typeof(Operation), new XmlAttributes());
table.Add(typeof(PortType), new XmlAttributes());
table.Add(typeof(Message), new XmlAttributes());
table.Add(typeof(MessagePart), new XmlAttributes());
table.Add(typeof(Types), new XmlAttributes());
Hashtable extensions = new Hashtable();
foreach (Type extensionType in extensionTypes) {
if (extensions[extensionType] != null) {
continue;
}
extensions.Add(extensionType, extensionType);
object[] attrs = extensionType.GetCustomAttributes(typeof(XmlFormatExtensionAttribute), false);
if (attrs.Length == 0) {
throw new ArgumentException(Res.GetString(Res.RequiredXmlFormatExtensionAttributeIsMissing1, extensionType.FullName), "extensionTypes");
}
XmlFormatExtensionAttribute extensionAttr = (XmlFormatExtensionAttribute)attrs[0];
foreach (Type extensionPointType in extensionAttr.ExtensionPoints) {
XmlAttributes xmlAttrs = (XmlAttributes)table[extensionPointType];
if (xmlAttrs == null) {
xmlAttrs = new XmlAttributes();
table.Add(extensionPointType, xmlAttrs);
}
XmlElementAttribute xmlAttr = new XmlElementAttribute(extensionAttr.ElementName, extensionType);
xmlAttr.Namespace = extensionAttr.Namespace;
xmlAttrs.XmlElements.Add(xmlAttr);
}
attrs = extensionType.GetCustomAttributes(typeof(XmlFormatExtensionPrefixAttribute), false);
string[] prefixes = new string[attrs.Length];
Hashtable nsDefs = new Hashtable();
for (int i = 0; i < attrs.Length; i++) {
XmlFormatExtensionPrefixAttribute prefixAttr = (XmlFormatExtensionPrefixAttribute)attrs[i];
prefixes[i] = prefixAttr.Prefix;
nsDefs.Add(prefixAttr.Prefix, prefixAttr.Namespace);
}
Array.Sort(prefixes, InvariantComparer.Default);
for (int i = 0; i < prefixes.Length; i++) {
namespaces.Add(prefixes[i], (string)nsDefs[prefixes[i]]);
}
}
foreach (Type extensionPointType in table.Keys) {
XmlFormatExtensionPointAttribute attr = GetExtensionPointAttribute(extensionPointType);
XmlAttributes xmlAttrs = (XmlAttributes)table[extensionPointType];
if (attr.AllowElements) {
xmlAttrs.XmlAnyElements.Add(new XmlAnyElementAttribute());
}
overrides.Add(extensionPointType, attr.MemberName, xmlAttrs);
}
}
internal Type[] MimeImporterTypes {
get { return this.mimeImporterTypes; }
}
internal Type[] MimeReflectorTypes {
get { return this.mimeReflectorTypes; }
}
internal Type[] ParameterReaderTypes {
get { return this.parameterReaderTypes; }
}
protected override ConfigurationPropertyCollection Properties {
get { return this.properties; }
}
internal Type[] ProtocolImporterTypes {
get {
if (this.protocolImporterTypes.Length == 0) {
lock (WebServicesSection.ClassSyncObject) {
if (this.protocolImporterTypes.Length == 0) {
WebServiceProtocols enabledProtocols = this.EnabledProtocols;
List<Type> protocolImporterList = new List<Type>();
// order is important for soap: 1.2 must come after 1.1
if ((enabledProtocols & WebServiceProtocols.HttpSoap) != 0) {
protocolImporterList.Add(typeof(SoapProtocolImporter));
}
if ((enabledProtocols & WebServiceProtocols.HttpSoap12) != 0) {
protocolImporterList.Add(typeof(Soap12ProtocolImporter));
}
if ((enabledProtocols & WebServiceProtocols.HttpGet) != 0) {
protocolImporterList.Add(typeof(HttpGetProtocolImporter));
}
if ((enabledProtocols & WebServiceProtocols.HttpPost) != 0) {
protocolImporterList.Add(typeof(HttpPostProtocolImporter));
}
this.protocolImporterTypes = protocolImporterList.ToArray();
}
}
}
return this.protocolImporterTypes;
}
set { this.protocolImporterTypes = value; }
}
internal Type[] ProtocolReflectorTypes {
get {
if (this.protocolReflectorTypes.Length == 0) {
lock (WebServicesSection.ClassSyncObject) {
if (this.protocolReflectorTypes.Length == 0) {
WebServiceProtocols enabledProtocols = this.EnabledProtocols;
List<Type> protocolReflectorList = new List<Type>();
// order is important for soap: 1.2 must come after 1.1
if ((enabledProtocols & WebServiceProtocols.HttpSoap) != 0) {
protocolReflectorList.Add(typeof(SoapProtocolReflector));
}
if ((enabledProtocols & WebServiceProtocols.HttpSoap12) != 0) {
protocolReflectorList.Add(typeof(Soap12ProtocolReflector));
}
if ((enabledProtocols & WebServiceProtocols.HttpGet) != 0) {
protocolReflectorList.Add(typeof(HttpGetProtocolReflector));
}
if ((enabledProtocols & WebServiceProtocols.HttpPost) != 0) {
protocolReflectorList.Add(typeof(HttpPostProtocolReflector));
}
this.protocolReflectorTypes = protocolReflectorList.ToArray();
}
}
}
return this.protocolReflectorTypes;
}
set { this.protocolReflectorTypes = value; }
}
[ConfigurationProperty("protocols")]
public ProtocolElementCollection Protocols {
get { return (ProtocolElementCollection)base[this.protocols]; }
}
[ConfigurationProperty("soapEnvelopeProcessing")]
public SoapEnvelopeProcessingElement SoapEnvelopeProcessing {
get { return (SoapEnvelopeProcessingElement)base[this.soapEnvelopeProcessing]; }
set { base[this.soapEnvelopeProcessing] = value; }
}
public DiagnosticsElement Diagnostics {
get { return (DiagnosticsElement)base[this.diagnostics]; }
set { base[this.diagnostics] = value; }
}
protected override void Reset(ConfigurationElement parentElement) {
// Fixes potential race condition where serverProtocolFactories != enabledProtocols settings
this.serverProtocolFactories = null;
this.enabledProtocols = WebServiceProtocols.Unknown;
if (parentElement != null) {
WebServicesSection parent = (WebServicesSection)parentElement;
this.discoveryDocumentSerializer = parent.discoveryDocumentSerializer;
}
base.Reset(parentElement);
}
internal Type[] ReturnWriterTypes {
get { return this.returnWriterTypes; }
}
internal ServerProtocolFactory[] ServerProtocolFactories {
get {
if (this.serverProtocolFactories == null) {
lock (WebServicesSection.ClassSyncObject) {
if (this.serverProtocolFactories == null) {
WebServiceProtocols enabledProtocols = this.EnabledProtocols;
List<ServerProtocolFactory> serverProtocolFactoryList = new List<ServerProtocolFactory>();
// These are order sensitive. We want SOAP to go first for perf
// and Discovery (?wsdl and ?disco) should go before Documentation
// both soap versions are handled by the same factory
if ((enabledProtocols & WebServiceProtocols.AnyHttpSoap) != 0) {
serverProtocolFactoryList.Add((ServerProtocolFactory)Activator.CreateInstance(this.SoapServerProtocolFactory));
}
if ((enabledProtocols & WebServiceProtocols.HttpPost) != 0) {
serverProtocolFactoryList.Add(new HttpPostServerProtocolFactory());
}
if ((enabledProtocols & WebServiceProtocols.HttpPostLocalhost) != 0) {
serverProtocolFactoryList.Add(new HttpPostLocalhostServerProtocolFactory());
}
if ((enabledProtocols & WebServiceProtocols.HttpGet) != 0) {
serverProtocolFactoryList.Add(new HttpGetServerProtocolFactory());
}
if ((enabledProtocols & WebServiceProtocols.Documentation) != 0) {
serverProtocolFactoryList.Add(new DiscoveryServerProtocolFactory());
serverProtocolFactoryList.Add(new DocumentationServerProtocolFactory());
}
this.serverProtocolFactories = serverProtocolFactoryList.ToArray();
}
}
}
return this.serverProtocolFactories;
}
}
internal bool ServiceDescriptionExtended {
get { return this.ServiceDescriptionFormatExtensionTypes.Count > 0; }
}
[ConfigurationProperty("serviceDescriptionFormatExtensionTypes")]
public TypeElementCollection ServiceDescriptionFormatExtensionTypes {
get { return (TypeElementCollection)base[this.serviceDescriptionFormatExtensionTypes]; }
}
[ConfigurationProperty("soapExtensionImporterTypes")]
public TypeElementCollection SoapExtensionImporterTypes {
get { return (TypeElementCollection)base[this.soapExtensionImporterTypes]; }
}
[ConfigurationProperty("soapExtensionReflectorTypes")]
public TypeElementCollection SoapExtensionReflectorTypes {
get { return (TypeElementCollection)base[this.soapExtensionReflectorTypes]; }
}
[ConfigurationProperty("soapExtensionTypes")]
public SoapExtensionTypeElementCollection SoapExtensionTypes {
get { return (SoapExtensionTypeElementCollection)base[this.soapExtensionTypes]; }
}
[ConfigurationProperty("soapServerProtocolFactory")]
public TypeElement SoapServerProtocolFactoryType {
get { return (TypeElement)base[this.soapServerProtocolFactoryType]; }
}
internal Type SoapServerProtocolFactory {
get {
if (this.soapServerProtocolFactory == null) {
lock (WebServicesSection.ClassSyncObject) {
if (this.soapServerProtocolFactory == null) {
this.soapServerProtocolFactory = this.SoapServerProtocolFactoryType.Type;
}
}
}
return this.soapServerProtocolFactory;
}
}
[ConfigurationProperty("soapTransportImporterTypes")]
public TypeElementCollection SoapTransportImporterTypes {
get { return (TypeElementCollection)base[this.soapTransportImporterTypes]; }
}
internal Type[] SoapTransportImporters {
get {
Type[] retval = new Type[1 + this.SoapTransportImporterTypes.Count];
retval[0] = typeof(SoapHttpTransportImporter);
for (int i = 0; i < SoapTransportImporterTypes.Count; ++i) {
retval[i + 1] = SoapTransportImporterTypes[i].Type;
}
return retval;
}
}
void TurnOnGetAndPost() {
bool needPost = (this.EnabledProtocols & WebServiceProtocols.HttpPost) == 0;
bool needGet = (this.EnabledProtocols & WebServiceProtocols.HttpGet) == 0;
if (!needGet && !needPost)
return;
ArrayList importers = new ArrayList(ProtocolImporterTypes);
ArrayList reflectors = new ArrayList(ProtocolReflectorTypes);
if (needPost) {
importers.Add(typeof(HttpPostProtocolImporter));
reflectors.Add(typeof(HttpPostProtocolReflector));
}
if (needGet) {
importers.Add(typeof(HttpGetProtocolImporter));
reflectors.Add(typeof(HttpGetProtocolReflector));
}
ProtocolImporterTypes = (Type[])importers.ToArray(typeof(Type));
ProtocolReflectorTypes = (Type[])reflectors.ToArray(typeof(Type));
enabledProtocols |= WebServiceProtocols.HttpGet | WebServiceProtocols.HttpPost;
}
[ConfigurationProperty("wsdlHelpGenerator")]
public WsdlHelpGeneratorElement WsdlHelpGenerator {
get { return (WsdlHelpGeneratorElement)base[this.wsdlHelpGenerator]; }
}
ConfigurationPropertyCollection properties = new ConfigurationPropertyCollection();
// Object for synchronizing access to the entire class( avoiding lock( typeof( ... )) )
static object classSyncObject = null;
const string SectionName = @"system.web/webServices";
readonly ConfigurationProperty conformanceWarnings = new ConfigurationProperty("conformanceWarnings", typeof(WsiProfilesElementCollection), null, ConfigurationPropertyOptions.None);
readonly ConfigurationProperty protocols = new ConfigurationProperty("protocols", typeof(ProtocolElementCollection), null, ConfigurationPropertyOptions.None);
readonly ConfigurationProperty serviceDescriptionFormatExtensionTypes = new ConfigurationProperty("serviceDescriptionFormatExtensionTypes", typeof(TypeElementCollection), null, ConfigurationPropertyOptions.None);
readonly ConfigurationProperty soapEnvelopeProcessing = new ConfigurationProperty("soapEnvelopeProcessing", typeof(SoapEnvelopeProcessingElement), null, ConfigurationPropertyOptions.None);
readonly ConfigurationProperty soapExtensionImporterTypes = new ConfigurationProperty("soapExtensionImporterTypes", typeof(TypeElementCollection), null, ConfigurationPropertyOptions.None);
readonly ConfigurationProperty soapExtensionReflectorTypes = new ConfigurationProperty("soapExtensionReflectorTypes", typeof(TypeElementCollection), null, ConfigurationPropertyOptions.None);
readonly ConfigurationProperty soapExtensionTypes = new ConfigurationProperty("soapExtensionTypes", typeof(SoapExtensionTypeElementCollection), null, ConfigurationPropertyOptions.None);
readonly ConfigurationProperty soapTransportImporterTypes = new ConfigurationProperty("soapTransportImporterTypes", typeof(TypeElementCollection), null, ConfigurationPropertyOptions.None);
readonly ConfigurationProperty wsdlHelpGenerator = new ConfigurationProperty("wsdlHelpGenerator", typeof(WsdlHelpGeneratorElement), null, ConfigurationPropertyOptions.None);
readonly ConfigurationProperty soapServerProtocolFactoryType = new ConfigurationProperty("soapServerProtocolFactory", typeof(TypeElement), null, ConfigurationPropertyOptions.None);
readonly ConfigurationProperty diagnostics = new ConfigurationProperty("diagnostics", typeof(DiagnosticsElement), null, ConfigurationPropertyOptions.None);
Type[] defaultFormatTypes = new Type[] {
typeof(HttpAddressBinding),
typeof(HttpBinding),
typeof(HttpOperationBinding),
typeof(HttpUrlEncodedBinding),
typeof(HttpUrlReplacementBinding),
typeof(MimeContentBinding),
typeof(MimeXmlBinding),
typeof(MimeMultipartRelatedBinding),
typeof(MimeTextBinding),
typeof(System.Web.Services.Description.SoapBinding),
typeof(SoapOperationBinding),
typeof(SoapBodyBinding),
typeof(SoapFaultBinding),
typeof(SoapHeaderBinding),
typeof(SoapAddressBinding),
typeof(Soap12Binding),
typeof(Soap12OperationBinding),
typeof(Soap12BodyBinding),
typeof(Soap12FaultBinding),
typeof(Soap12HeaderBinding),
typeof(Soap12AddressBinding) };
Type[] discoveryReferenceTypes = new Type[] { typeof(DiscoveryDocumentReference), typeof(ContractReference), typeof(SchemaReference), typeof(System.Web.Services.Discovery.SoapBinding) };
XmlSerializer discoveryDocumentSerializer = null;
WebServiceProtocols enabledProtocols = WebServiceProtocols.Unknown;
Type[] mimeImporterTypes = new Type[] { typeof(MimeXmlImporter), typeof(MimeFormImporter), typeof(MimeTextImporter) };
Type[] mimeReflectorTypes = new Type[] { typeof(MimeXmlReflector), typeof(MimeFormReflector) };
Type[] parameterReaderTypes = new Type[] { typeof(UrlParameterReader), typeof(HtmlFormParameterReader) };
Type[] protocolImporterTypes = new Type[0];
Type[] protocolReflectorTypes = new Type[0];
Type[] returnWriterTypes = new Type[] { typeof(XmlReturnWriter) };
ServerProtocolFactory[] serverProtocolFactories = null;
Type soapServerProtocolFactory = null;
}
}