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

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

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

    class HostedNamedPipeTransportManager : NamedPipeTransportManager
    { 
        bool settingsApplied;
        OnViaDelegate onViaCallback; 
        SharedConnectionListener listener; 
        ConnectionDemuxer connectionDemuxer;
        int queueId; 
        Guid token;
        OnDuplicatedViaDelegate onDuplicatedViaCallback;
        bool demuxerCreated;
 
        public HostedNamedPipeTransportManager(BaseUriWithWildcard baseAddress)
            : base(baseAddress.BaseAddress) 
        { 
            this.HostNameComparisonMode = baseAddress.HostNameComparisonMode;
            this.onViaCallback = new OnViaDelegate(OnVia); 
            this.onDuplicatedViaCallback = new OnDuplicatedViaDelegate(OnDuplicatedVia);
        }

        protected override bool IsCompatible(NamedPipeChannelListener channelListener) 
        {
            if (channelListener.HostedVirtualPath == null) 
            { 
                return false;
            } 

            return base.IsCompatible(channelListener);
        }
 
        internal void Start(int queueId, Guid token, MessageReceivedCallback messageReceivedCallback)
        { 
            SetMessageReceivedCallback(messageReceivedCallback); 
            OnOpenInternal(queueId, token);
        } 

        internal override void OnOpen()
        {
            // This is intentionally empty. 
        }
 
        internal void Stop() 
        {
            lock (ThisLock) 
            {
                if (listener != null)
                {
                    listener.Stop(); 

                    // The listener will be closed by the demuxer. 
                    listener = null; 
                }
 
                if (connectionDemuxer != null)
                {
                    connectionDemuxer.Dispose();
                } 

                demuxerCreated = false; 
                settingsApplied = false; 
            }
        } 

        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(onViaCallback); 
        }

        void OnOpenInternal(int queueId, Guid token)
        { 
            lock (ThisLock)
            { 
                this.queueId = queueId; 
                this.token = token;
 
                BaseUriWithWildcard path = new BaseUriWithWildcard(this.ListenUri, this.HostNameComparisonMode);

                listener = new SharedConnectionListener(path, queueId, token,
                    this.onDuplicatedViaCallback); 
            }
        } 
 
        internal override void OnClose()
        { 
            Stop();

            base.OnClose();
        } 

        void OnVia(Uri address) 
        { 
            Debug.Print("HostedNamedPipeTransportManager.OnVia() address: " + address + " calling EnsureServiceAvailable()");
            ServiceHostingEnvironment.EnsureServiceAvailable(address.LocalPath); 
        }

        protected override void OnSelecting(NamedPipeChannelListener channelListener)
        { 
            if (settingsApplied)
            { 
                return; 
            }
 
            lock (ThisLock)
            {
                if (settingsApplied)
                { 
                    // Use the setting for the first one.
                    return; 
                } 

                this.ApplyListenerSettings(channelListener); 
                settingsApplied = true;
            }
        }
 
        // This method is called only for the first via of the current proxy.
        void OnDuplicatedVia(Uri via, out int connectionBufferSize) 
        { 
            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;
        }
    } 
}

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