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

446 lines
16 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime;
using System.ServiceModel;
using System.ServiceModel.Description;
using System.Xml;
public abstract class ConnectionOrientedTransportBindingElement
: TransportBindingElement,
IWsdlExportExtension,
IPolicyExportExtension,
ITransportPolicyImport
{
int connectionBufferSize;
bool exposeConnectionProperty;
HostNameComparisonMode hostNameComparisonMode;
bool inheritBaseAddressSettings;
TimeSpan channelInitializationTimeout;
int maxBufferSize;
bool maxBufferSizeInitialized;
int maxPendingConnections;
TimeSpan maxOutputDelay;
int maxPendingAccepts;
TransferMode transferMode;
bool isMaxPendingConnectionsSet;
bool isMaxPendingAcceptsSet;
internal ConnectionOrientedTransportBindingElement()
: base()
{
this.connectionBufferSize = ConnectionOrientedTransportDefaults.ConnectionBufferSize;
this.hostNameComparisonMode = ConnectionOrientedTransportDefaults.HostNameComparisonMode;
this.channelInitializationTimeout = ConnectionOrientedTransportDefaults.ChannelInitializationTimeout;
this.maxBufferSize = TransportDefaults.MaxBufferSize;
this.maxPendingConnections = ConnectionOrientedTransportDefaults.GetMaxPendingConnections();
this.maxOutputDelay = ConnectionOrientedTransportDefaults.MaxOutputDelay;
this.maxPendingAccepts = ConnectionOrientedTransportDefaults.GetMaxPendingAccepts();
this.transferMode = ConnectionOrientedTransportDefaults.TransferMode;
}
internal ConnectionOrientedTransportBindingElement(ConnectionOrientedTransportBindingElement elementToBeCloned)
: base(elementToBeCloned)
{
this.connectionBufferSize = elementToBeCloned.connectionBufferSize;
this.exposeConnectionProperty = elementToBeCloned.exposeConnectionProperty;
this.hostNameComparisonMode = elementToBeCloned.hostNameComparisonMode;
this.inheritBaseAddressSettings = elementToBeCloned.InheritBaseAddressSettings;
this.channelInitializationTimeout = elementToBeCloned.ChannelInitializationTimeout;
this.maxBufferSize = elementToBeCloned.maxBufferSize;
this.maxBufferSizeInitialized = elementToBeCloned.maxBufferSizeInitialized;
this.maxPendingConnections = elementToBeCloned.maxPendingConnections;
this.maxOutputDelay = elementToBeCloned.maxOutputDelay;
this.maxPendingAccepts = elementToBeCloned.maxPendingAccepts;
this.transferMode = elementToBeCloned.transferMode;
this.isMaxPendingConnectionsSet = elementToBeCloned.isMaxPendingConnectionsSet;
this.isMaxPendingAcceptsSet = elementToBeCloned.isMaxPendingAcceptsSet;
}
// client
// server
[DefaultValue(ConnectionOrientedTransportDefaults.ConnectionBufferSize)]
public int ConnectionBufferSize
{
get
{
return this.connectionBufferSize;
}
set
{
if (value < 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
SR.GetString(SR.ValueMustBeNonNegative)));
}
this.connectionBufferSize = value;
}
}
// client
internal bool ExposeConnectionProperty
{
get
{
return this.exposeConnectionProperty;
}
set
{
this.exposeConnectionProperty = value;
}
}
[DefaultValue(ConnectionOrientedTransportDefaults.HostNameComparisonMode)]
public HostNameComparisonMode HostNameComparisonMode
{
get
{
return this.hostNameComparisonMode;
}
set
{
HostNameComparisonModeHelper.Validate(value);
this.hostNameComparisonMode = value;
}
}
// server
[DefaultValue(TransportDefaults.MaxBufferSize)]
public int MaxBufferSize
{
get
{
if (maxBufferSizeInitialized || TransferMode != TransferMode.Buffered)
{
return maxBufferSize;
}
long maxReceivedMessageSize = MaxReceivedMessageSize;
if (maxReceivedMessageSize > int.MaxValue)
{
return int.MaxValue;
}
else
{
return (int)maxReceivedMessageSize;
}
}
set
{
if (value <= 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
SR.GetString(SR.ValueMustBePositive)));
}
maxBufferSizeInitialized = true;
this.maxBufferSize = value;
}
}
// server
public int MaxPendingConnections
{
get
{
return this.maxPendingConnections;
}
set
{
if (value <= 0)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
SR.GetString(SR.ValueMustBePositive)));
this.maxPendingConnections = value;
this.isMaxPendingConnectionsSet = true;
}
}
internal bool IsMaxPendingConnectionsSet
{
get { return this.isMaxPendingConnectionsSet; }
}
// MB#26970: used by MEX to ensure that we don't conflict on base-address scoped settings
internal bool InheritBaseAddressSettings
{
get
{
return this.inheritBaseAddressSettings;
}
set
{
this.inheritBaseAddressSettings = value;
}
}
// server
[DefaultValue(typeof(TimeSpan), ConnectionOrientedTransportDefaults.ChannelInitializationTimeoutString)]
public TimeSpan ChannelInitializationTimeout
{
get
{
return this.channelInitializationTimeout;
}
set
{
if (value <= TimeSpan.Zero)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
SR.GetString(SR.TimeSpanMustbeGreaterThanTimeSpanZero)));
}
if (TimeoutHelper.IsTooLarge(value))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
SR.GetString(SR.SFxTimeoutOutOfRangeTooBig)));
}
this.channelInitializationTimeout = value;
}
}
// server
[DefaultValue(typeof(TimeSpan), ConnectionOrientedTransportDefaults.MaxOutputDelayString)]
public TimeSpan MaxOutputDelay
{
get
{
return this.maxOutputDelay;
}
set
{
if (value < TimeSpan.Zero)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
SR.GetString(SR.SFxTimeoutOutOfRange0)));
}
if (TimeoutHelper.IsTooLarge(value))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
SR.GetString(SR.SFxTimeoutOutOfRangeTooBig)));
}
this.maxOutputDelay = value;
}
}
// server
public int MaxPendingAccepts
{
get
{
return this.maxPendingAccepts;
}
set
{
if (value <= 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value", value,
SR.GetString(SR.ValueMustBePositive)));
}
this.maxPendingAccepts = value;
this.isMaxPendingAcceptsSet = true;
}
}
internal bool IsMaxPendingAcceptsSet
{
get { return this.isMaxPendingAcceptsSet; }
}
// client
// server
[DefaultValue(ConnectionOrientedTransportDefaults.TransferMode)]
public TransferMode TransferMode
{
get
{
return this.transferMode;
}
set
{
TransferModeHelper.Validate(value);
this.transferMode = value;
}
}
public override bool CanBuildChannelFactory<TChannel>(BindingContext context)
{
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
if (TransferMode == TransferMode.Buffered)
{
return (typeof(TChannel) == typeof(IDuplexSessionChannel));
}
else
{
return (typeof(TChannel) == typeof(IRequestChannel));
}
}
public override bool CanBuildChannelListener<TChannel>(BindingContext context)
{
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
if (TransferMode == TransferMode.Buffered)
{
return (typeof(TChannel) == typeof(IDuplexSessionChannel));
}
else
{
return (typeof(TChannel) == typeof(IReplyChannel));
}
}
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context)
{
if (exporter == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exporter");
}
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
ICollection<XmlElement> policyAssertions = context.GetBindingAssertions();
if (TransferModeHelper.IsRequestStreamed(this.TransferMode)
|| TransferModeHelper.IsResponseStreamed(this.TransferMode))
{
policyAssertions.Add(new XmlDocument().CreateElement(TransportPolicyConstants.DotNetFramingPrefix,
TransportPolicyConstants.StreamedName, TransportPolicyConstants.DotNetFramingNamespace));
}
bool createdNew;
MessageEncodingBindingElement encodingBindingElement = FindMessageEncodingBindingElement(context.BindingElements, out createdNew);
if (createdNew && encodingBindingElement is IPolicyExportExtension)
{
encodingBindingElement = new BinaryMessageEncodingBindingElement();
((IPolicyExportExtension)encodingBindingElement).ExportPolicy(exporter, context);
}
WsdlExporter.WSAddressingHelper.AddWSAddressingAssertion(exporter, context, encodingBindingElement.MessageVersion.Addressing);
}
void IWsdlExportExtension.ExportContract(WsdlExporter exporter, WsdlContractConversionContext context) { }
internal abstract string WsdlTransportUri { get; }
void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext endpointContext)
{
bool createdNew;
MessageEncodingBindingElement encodingBindingElement = FindMessageEncodingBindingElement(endpointContext, out createdNew);
TransportBindingElement.ExportWsdlEndpoint(exporter, endpointContext, this.WsdlTransportUri, encodingBindingElement.MessageVersion.Addressing);
}
void ITransportPolicyImport.ImportPolicy(MetadataImporter importer, PolicyConversionContext policyContext)
{
if (PolicyConversionContext.FindAssertion(policyContext.GetBindingAssertions(), TransportPolicyConstants.StreamedName, TransportPolicyConstants.DotNetFramingNamespace, true) != null)
{
this.TransferMode = TransferMode.Streamed;
}
WindowsStreamSecurityBindingElement.ImportPolicy(importer, policyContext);
SslStreamSecurityBindingElement.ImportPolicy(importer, policyContext);
}
public override T GetProperty<T>(BindingContext context)
{
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
if (typeof(T) == typeof(TransferMode))
{
return (T)(object)this.TransferMode;
}
else
{
return base.GetProperty<T>(context);
}
}
internal override bool IsMatch(BindingElement b)
{
if (!base.IsMatch(b))
return false;
ConnectionOrientedTransportBindingElement connection = b as ConnectionOrientedTransportBindingElement;
if (connection == null)
return false;
if (this.connectionBufferSize != connection.connectionBufferSize)
return false;
if (this.hostNameComparisonMode != connection.hostNameComparisonMode)
return false;
if (this.inheritBaseAddressSettings != connection.inheritBaseAddressSettings)
return false;
if (this.channelInitializationTimeout != connection.channelInitializationTimeout)
{
return false;
}
if (this.maxBufferSize != connection.maxBufferSize)
return false;
if (this.maxPendingConnections != connection.maxPendingConnections)
return false;
if (this.maxOutputDelay != connection.maxOutputDelay)
return false;
if (this.maxPendingAccepts != connection.maxPendingAccepts)
return false;
if (this.transferMode != connection.transferMode)
return false;
return true;
}
MessageEncodingBindingElement FindMessageEncodingBindingElement(BindingElementCollection bindingElements, out bool createdNew)
{
createdNew = false;
MessageEncodingBindingElement encodingBindingElement = bindingElements.Find<MessageEncodingBindingElement>();
if (encodingBindingElement == null)
{
createdNew = true;
encodingBindingElement = new BinaryMessageEncodingBindingElement();
}
return encodingBindingElement;
}
MessageEncodingBindingElement FindMessageEncodingBindingElement(WsdlEndpointConversionContext endpointContext, out bool createdNew)
{
BindingElementCollection bindingElements = endpointContext.Endpoint.Binding.CreateBindingElements();
return FindMessageEncodingBindingElement(bindingElements, out createdNew);
}
[EditorBrowsable(EditorBrowsableState.Never)]
public bool ShouldSerializeMaxPendingAccepts()
{
return this.isMaxPendingAcceptsSet;
}
[EditorBrowsable(EditorBrowsableState.Never)]
public bool ShouldSerializeMaxPendingConnections()
{
return this.isMaxPendingConnectionsSet;
}
}
}