mono/mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Channels/LayeredChannelFactory.cs

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

namespace System.ServiceModel.Channels
{
    using System.Runtime;
    using System.ServiceModel;

    abstract class LayeredChannelFactory<TChannel> : ChannelFactoryBase<TChannel>
    {
        IChannelFactory innerChannelFactory;

        public LayeredChannelFactory(IDefaultCommunicationTimeouts timeouts, IChannelFactory innerChannelFactory)
            : base(timeouts)
        {
            this.innerChannelFactory = innerChannelFactory;
        }

        protected IChannelFactory InnerChannelFactory
        {
            get { return this.innerChannelFactory; }
        }

        public override T GetProperty<T>()
        {
            if (typeof(T) == typeof(IChannelFactory<TChannel>))
            {
                return (T)(object)this;
            }

            T baseProperty = base.GetProperty<T>();
            if (baseProperty != null)
            {
                return baseProperty;
            }

            return this.innerChannelFactory.GetProperty<T>();
        }

        protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return this.innerChannelFactory.BeginOpen(timeout, callback, state);
        }

        protected override void OnEndOpen(IAsyncResult result)
        {
            this.innerChannelFactory.EndOpen(result);
        }

        protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return new ChainedCloseAsyncResult(timeout, callback, state, base.OnBeginClose, base.OnEndClose, this.innerChannelFactory);
        }

        protected override void OnEndClose(IAsyncResult result)
        {
            ChainedCloseAsyncResult.End(result);
        }

        protected override void OnClose(TimeSpan timeout)
        {
            TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
            base.OnClose(timeoutHelper.RemainingTime());
            this.innerChannelFactory.Close(timeoutHelper.RemainingTime());
        }

        protected override void OnOpen(TimeSpan timeout)
        {
            this.innerChannelFactory.Open(timeout);
        }

        protected override void OnAbort()
        {
            base.OnAbort();
            this.innerChannelFactory.Abort();
        }
    }

    class LayeredInputChannel : LayeredChannel<IInputChannel>, IInputChannel
    {
        public LayeredInputChannel(ChannelManagerBase channelManager, IInputChannel innerChannel)
            : base(channelManager, innerChannel)
        {
        }

        public virtual EndpointAddress LocalAddress
        {
            get { return InnerChannel.LocalAddress; }
        }

        void InternalOnReceive(Message message)
        {
            if (message != null)
            {
                this.OnReceive(message);
            }
        }

        protected virtual void OnReceive(Message message)
        {
        }

        public Message Receive()
        {
            Message message = InnerChannel.Receive();
            this.InternalOnReceive(message);
            return message;
        }

        public Message Receive(TimeSpan timeout)
        {
            Message message = InnerChannel.Receive(timeout);
            this.InternalOnReceive(message);
            return message;
        }

        public IAsyncResult BeginReceive(AsyncCallback callback, object state)
        {
            return InnerChannel.BeginReceive(callback, state);
        }

        public IAsyncResult BeginReceive(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return InnerChannel.BeginReceive(timeout, callback, state);
        }

        public Message EndReceive(IAsyncResult result)
        {
            Message message = InnerChannel.EndReceive(result);
            this.InternalOnReceive(message);
            return message;
        }

        public IAsyncResult BeginTryReceive(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return InnerChannel.BeginTryReceive(timeout, callback, state);
        }

        public bool EndTryReceive(IAsyncResult result, out Message message)
        {
            bool retVal = InnerChannel.EndTryReceive(result, out message);
            this.InternalOnReceive(message);
            return retVal;
        }

        public bool TryReceive(TimeSpan timeout, out Message message)
        {
            bool retVal = InnerChannel.TryReceive(timeout, out message);
            this.InternalOnReceive(message);
            return retVal;
        }

        public bool WaitForMessage(TimeSpan timeout)
        {
            return InnerChannel.WaitForMessage(timeout);
        }

        public IAsyncResult BeginWaitForMessage(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return InnerChannel.BeginWaitForMessage(timeout, callback, state);
        }

        public bool EndWaitForMessage(IAsyncResult result)
        {
            return InnerChannel.EndWaitForMessage(result);
        }
    }

    class LayeredDuplexChannel : LayeredInputChannel, IDuplexChannel
    {
        IOutputChannel innerOutputChannel;
        EndpointAddress localAddress;
        EventHandler onInnerOutputChannelFaulted;

        public LayeredDuplexChannel(ChannelManagerBase channelManager, IInputChannel innerInputChannel, EndpointAddress localAddress, IOutputChannel innerOutputChannel)
            : base(channelManager, innerInputChannel)
        {
            this.localAddress = localAddress;
            this.innerOutputChannel = innerOutputChannel;
            this.onInnerOutputChannelFaulted = new EventHandler(OnInnerOutputChannelFaulted);
            this.innerOutputChannel.Faulted += this.onInnerOutputChannelFaulted;
        }

        public override EndpointAddress LocalAddress
        {
            get { return this.localAddress; }
        }

        public EndpointAddress RemoteAddress
        {
            get { return this.innerOutputChannel.RemoteAddress; }
        }

        public Uri Via
        {
            get { return innerOutputChannel.Via; }
        }

        protected override void OnClosing()
        {
            this.innerOutputChannel.Faulted -= this.onInnerOutputChannelFaulted;
            base.OnClosing();
        }

        protected override void OnAbort()
        {
            this.innerOutputChannel.Abort();
            base.OnAbort();
        }

        protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return new ChainedCloseAsyncResult(timeout, callback, state, base.OnBeginClose, base.OnEndClose, this.innerOutputChannel);
        }

        protected override void OnEndClose(IAsyncResult result)
        {
            ChainedCloseAsyncResult.End(result);
        }

        protected override void OnClose(TimeSpan timeout)
        {
            TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
            this.innerOutputChannel.Close(timeoutHelper.RemainingTime());
            base.OnClose(timeoutHelper.RemainingTime());
        }

        protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return new ChainedOpenAsyncResult(timeout, callback, state, base.OnBeginOpen, base.OnEndOpen, this.innerOutputChannel);
        }

        protected override void OnEndOpen(IAsyncResult result)
        {
            ChainedOpenAsyncResult.End(result);
        }

        protected override void OnOpen(TimeSpan timeout)
        {
            TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
            base.OnOpen(timeoutHelper.RemainingTime());
            innerOutputChannel.Open(timeoutHelper.RemainingTime());
        }

        public void Send(Message message)
        {
            this.Send(message, this.DefaultSendTimeout);
        }

        public void Send(Message message, TimeSpan timeout)
        {
            this.innerOutputChannel.Send(message, timeout);
        }

        public IAsyncResult BeginSend(Message message, AsyncCallback callback, object state)
        {
            return this.BeginSend(message, this.DefaultSendTimeout, callback, state);
        }

        public IAsyncResult BeginSend(Message message, TimeSpan timeout, AsyncCallback callback, object state)
        {
            return this.innerOutputChannel.BeginSend(message, timeout, callback, state);
        }

        public void EndSend(IAsyncResult result)
        {
            this.innerOutputChannel.EndSend(result);
        }

        void OnInnerOutputChannelFaulted(object sender, EventArgs e)
        {
            this.Fault();
        }
    }
}