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

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

namespace System.ServiceModel.Channels 
{
    using System; 
    using System.Diagnostics; 
    using System.ServiceModel;
    using System.ServiceModel.Diagnostics; 
    using System.ServiceModel.Dispatcher;
    using System.Threading;
    using System.ServiceModel.Security;
 
    class PeerOutputChannel : TransportOutputChannel
    { 
        PeerNode peerNode; 
        Uri via;
        EndpointAddress to; 
        SecurityProtocol securityProtocol;
        bool released = false;
        ChannelManagerBase channelManager;
 
        public PeerOutputChannel(PeerNodeImplementation peerNode, PeerNodeImplementation.Registration registration, ChannelManagerBase channelManager,
            EndpointAddress localAddress, Uri via, MessageVersion messageVersion) 
            : base(channelManager, localAddress, via, false, messageVersion) 
        {
            PeerNodeImplementation.ValidateVia(via); 
            if(registration != null)
            {
                peerNode = PeerNodeImplementation.Get(via, registration);
            } 
            this.peerNode = new PeerNode(peerNode);
            this.via = via; 
            this.channelManager = channelManager; 
            this.to = localAddress;
        } 

        public override T GetProperty()
        {
            if(typeof(T) == typeof(PeerNode)) 
            {
                return (T) (object) this.peerNode; 
            } 
            else if(typeof(T) == typeof(PeerNodeImplementation))
            { 
                return  (T) (object) this.peerNode.InnerNode;
            }
            else if(typeof(T) == typeof(IOnlineStatus))
            { 
                return (T) (object) this.peerNode;
            } 
            else if (typeof(T) == typeof(FaultConverter)) 
            {
                return (T)(object)FaultConverter.GetDefaultFaultConverter(MessageVersion.Soap12WSAddressing10); 
            }
            return base.GetProperty();
        }
 
        protected override void OnAbort()
        { 
            if (this.State < CommunicationState.Closed) 
            {
                try 
                {
                    this.peerNode.InnerNode.Abort();
                }
                catch(Exception e) 
                {
                    if(DiagnosticUtility.IsFatal(e)) throw; 
                    DiagnosticUtility.ExceptionUtility.TraceHandledException(e, TraceEventType.Information); 
                }
            } 
        }

        protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
        { 
            return this.peerNode.InnerNode.BeginClose(timeout, callback, state);
        } 
 
        protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
        { 
            IAsyncResult result = this.peerNode.InnerNode.BeginOpen(timeout, callback, state, true);
            return result;
        }
 
        protected override void OnClose(TimeSpan timeout)
        { 
            this.peerNode.InnerNode.Close(timeout); 
        }
 
        protected override void OnClosing()
        {
            base.OnClosing();
            ReleaseNode(); 
        }
 
        void ReleaseNode() 
        {
            if (!this.released) 
            {
                bool release = false;
                lock(ThisLock)
                { 
                    if (!this.released)
                    { 
                        release = this.released = true; 
                    }
                } 
                if (release && (this.peerNode != null))
                {
                    this.peerNode.InnerNode.Release();
                } 
            }
        } 
 
        protected override void OnOpen(TimeSpan timeout)
        { 
            this.peerNode.OnOpen();
            this.peerNode.InnerNode.Open(timeout, true);
        }
 
        protected override void OnFaulted()
        { 
            base.OnFaulted(); 
            ReleaseNode();
        } 

        protected override void OnEndClose(IAsyncResult result)
        {
            PeerNodeImplementation.EndClose(result); 
        }
 
        protected override void OnEndOpen(IAsyncResult result) 
        {
            PeerNodeImplementation.EndOpen(result); 
        }

        protected override void OnSend(Message message, TimeSpan timeout)
        { 
            EndSend(BeginSend(message, timeout, null, null));
        } 
 
        protected override IAsyncResult OnBeginSend(Message message, TimeSpan timeout, AsyncCallback callback, object state)
        { 
            TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);

            if (this.securityProtocol == null)
            { 
                lock(ThisLock)
                { 
                    if (this.securityProtocol == null) 
                    {
                        this.securityProtocol = ((IPeerFactory)channelManager).SecurityManager.CreateSecurityProtocol(this.to, timeoutHelper.RemainingTime()); 
                    }
                }
            }
            return this.peerNode.InnerNode.BeginSend(this, message, this.via, (ITransportFactorySettings)Manager, timeoutHelper.RemainingTime(), callback, state, this.securityProtocol); 
        }
 
        protected override void OnEndSend(IAsyncResult result) 
        {
            PeerNodeImplementation.EndSend(result); 
        }

        protected override void AddHeadersTo(Message message)
        { 
            this.RemoteAddress.ApplyTo(message);
        } 
    } 
}

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