Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

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

@@ -0,0 +1,276 @@
+//------------------------------------------------------------
+// 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();
+        }
+    }
+}