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