SharedTcpTransportManager.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 / SharedTcpTransportManager.cs / 1 / SharedTcpTransportManager.cs

                            //---------------------------------------------------------------------------- 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//---------------------------------------------------------------------------

namespace System.ServiceModel.Channels 
{
    using System.ServiceModel.Activation; 
    using System.Collections.Generic; 
    using System.Diagnostics;
    using System.ServiceModel; 
    using System.Threading;
    using System.ServiceModel.Diagnostics;

    class SharedTcpTransportManager : TcpTransportManager, ITransportManagerRegistration 
    {
        SharedConnectionListener listener; 
        ConnectionDemuxer connectionDemuxer; 
        HostNameComparisonMode hostNameComparisonMode;
        Uri listenUri; 
        int queueId;
        Guid token;
        OnDuplicatedViaDelegate onDuplicatedViaCallback;
        bool demuxerCreated; 

        public SharedTcpTransportManager(Uri listenUri, TcpChannelListener channelListener) 
        { 
            this.HostNameComparisonMode = channelListener.HostNameComparisonMode;
            this.listenUri = listenUri; 

            // For port sharing, we apply all of the settings from channel listener to the transport manager.
            this.ApplyListenerSettings(channelListener);
        } 

        protected SharedTcpTransportManager(Uri listenUri) 
        { 
            this.listenUri = listenUri;
        } 

        protected override bool IsCompatible(TcpChannelListener channelListener)
        {
            if (channelListener.HostedVirtualPath == null && !channelListener.PortSharingEnabled) 
            {
                return false; 
            } 

            return base.IsCompatible(channelListener); 
        }

        public HostNameComparisonMode HostNameComparisonMode
        { 
            get
            { 
                return this.hostNameComparisonMode; 
            }
            set 
            {
                HostNameComparisonModeHelper.Validate(value);
                lock (base.ThisLock)
                { 
                    ThrowIfOpen();
                    this.hostNameComparisonMode = value; 
                } 
            }
        } 

        public Uri ListenUri
        {
            get 
            {
                return this.listenUri; 
            } 
        }
 
        internal override void OnOpen()
        {
            OnOpenInternal(0, Guid.Empty);
        } 

        protected virtual OnViaDelegate GetOnViaCallback() 
        { 
            return null;
        } 

        // This method is called only for the first via of the current proxy.
        void OnDuplicatedVia(Uri via, out int connectionBufferSize)
        { 
            OnViaDelegate onVia = GetOnViaCallback();
            if (onVia != null) 
            { 
                onVia(via);
            } 

            if (!demuxerCreated)
            {
                lock (ThisLock) 
                {
                    if (listener == null) 
                    { 
                        // The listener has been stopped.
                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationObjectAbortedException( 
                            SR.GetString(SR.Sharing_ListenerProxyStopped)));
                    }

                    if (!demuxerCreated) 
                    {
                        CreateConnectionDemuxer(); 
                        demuxerCreated = true; 
                    }
                } 
            }

            connectionBufferSize = this.ConnectionBufferSize;
        } 

        void CreateConnectionDemuxer() 
        { 
            IConnectionListener connectionListener = new BufferedConnectionListener(listener, MaxOutputDelay, ConnectionBufferSize);
            if (DiagnosticUtility.ShouldUseActivity) 
            {
                connectionListener = new TracingConnectionListener(connectionListener, this.ListenUri);
            }
 
            connectionDemuxer = new ConnectionDemuxer(connectionListener,
                MaxPendingAccepts, MaxPendingConnections, ChannelInitializationTimeout, 
                IdleTimeout, MaxPooledConnections, 
                OnGetTransportFactorySettings,
                OnGetSingletonMessageHandler, 
                OnHandleServerSessionPreamble,
                OnDemuxerError);
            connectionDemuxer.StartDemuxing(this.GetOnViaCallback());
        } 

        internal void OnOpenInternal(int queueId, Guid token) 
        { 
            lock (ThisLock)
            { 
                this.queueId = queueId;
                this.token = token;

                BaseUriWithWildcard path = new BaseUriWithWildcard(this.ListenUri, this.HostNameComparisonMode); 

                if (this.onDuplicatedViaCallback == null) 
                { 
                    this.onDuplicatedViaCallback = new OnDuplicatedViaDelegate(OnDuplicatedVia);
                } 

                listener = new SharedConnectionListener(path, queueId, token,
                    this.onDuplicatedViaCallback);
 
                // Delay the creation of the demuxer on the first request.
            } 
        } 

        protected void CleanUp() 
        {
            lock (ThisLock)
            {
                if (listener != null) 
                {
                    listener.Stop(); 
 
                    // The listener will be closed by the demuxer.
                    listener = null; 
                }

                if (connectionDemuxer != null)
                { 
                    connectionDemuxer.Dispose();
                } 
 
                demuxerCreated = false;
            } 
        }

        internal override void OnClose()
        { 
            CleanUp();
 
            TcpChannelListener.StaticTransportManagerTable.UnregisterUri(this.ListenUri, this.HostNameComparisonMode); 
        }
 
        protected virtual void OnSelecting(TcpChannelListener channelListener)
        { }

        IList ITransportManagerRegistration.Select(TransportChannelListener channelListener) 
        {
            if (!channelListener.IsScopeIdCompatible(this.hostNameComparisonMode, this.listenUri)) 
            { 
                return null;
            } 

            OnSelecting((TcpChannelListener)channelListener);

            IList result = null; 
            if (this.IsCompatible((TcpChannelListener)channelListener))
            { 
                result = new List(); 
                result.Add(this);
            } 
            return result;
        }
    }
} 

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