ConnectionOrientedTransportBindingElement.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / ServiceModel / System / ServiceModel / Channels / ConnectionOrientedTransportBindingElement.cs / 1 / ConnectionOrientedTransportBindingElement.cs
                        

                        
                            //------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------
namespace System.ServiceModel.Channels
{ 
    using System.Collections.Generic;
    using System.ServiceModel.Description; 
    using System.Net.Security; 
    using System.Runtime.Serialization;
    using System.ServiceModel; 
    using System.Security.Principal;
    using System.ServiceModel.Security;
    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;
 
        internal ConnectionOrientedTransportBindingElement()
            : base() 
        { 
            this.connectionBufferSize = ConnectionOrientedTransportDefaults.ConnectionBufferSize;
            this.hostNameComparisonMode = ConnectionOrientedTransportDefaults.HostNameComparisonMode; 
            this.channelInitializationTimeout = ConnectionOrientedTransportDefaults.ChannelInitializationTimeout;
            this.maxBufferSize = TransportDefaults.MaxBufferSize;
            this.maxPendingConnections = ConnectionOrientedTransportDefaults.MaxPendingConnections;
            this.maxOutputDelay = ConnectionOrientedTransportDefaults.MaxOutputDelay; 
            this.maxPendingAccepts = ConnectionOrientedTransportDefaults.MaxPendingAccepts;
            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;
        } 

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

        public HostNameComparisonMode HostNameComparisonMode
        { 
            get
            { 
                return this.hostNameComparisonMode; 
            }
 
            set
            {
                HostNameComparisonModeHelper.Validate(value);
                this.hostNameComparisonMode = value; 
            }
        } 
 
        // server
        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; 
            }
        }

        // 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
        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 
        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; 
            }
        } 
 
        // client
        // server 
        public TransferMode TransferMode
        {
            get
            { 
                return this.transferMode;
            } 
            set 
            {
                TransferModeHelper.Validate(value); 
                this.transferMode = value;
            }
        }
 
        public override bool CanBuildChannelFactory(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(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 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(BindingContext context)
        {
            if (context == null)
            { 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
            } 
 
            if (typeof(T) == typeof(TransferMode))
            { 
                return (T)(object)this.TransferMode;
            }
            else
            { 
                return base.GetProperty(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(); 
            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);
        } 

    } 
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK