|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.ServiceModel.Channels;
namespace System.ServiceModel.Dispatcher
{
internal static class ListenerBinder
{
internal static IListenerBinder GetBinder(IChannelListener listener, MessageVersion messageVersion)
{
IChannelListener<IInputChannel> input = listener as IChannelListener<IInputChannel>;
if (input != null)
return new InputListenerBinder(input, messageVersion);
IChannelListener<IInputSessionChannel> inputSession = listener as IChannelListener<IInputSessionChannel>;
if (inputSession != null)
return new InputSessionListenerBinder(inputSession, messageVersion);
IChannelListener<IReplyChannel> reply = listener as IChannelListener<IReplyChannel>;
if (reply != null)
return new ReplyListenerBinder(reply, messageVersion);
IChannelListener<IReplySessionChannel> replySession = listener as IChannelListener<IReplySessionChannel>;
if (replySession != null)
return new ReplySessionListenerBinder(replySession, messageVersion);
IChannelListener<IDuplexChannel> duplex = listener as IChannelListener<IDuplexChannel>;
if (duplex != null)
return new DuplexListenerBinder(duplex, messageVersion);
IChannelListener<IDuplexSessionChannel> duplexSession = listener as IChannelListener<IDuplexSessionChannel>;
if (duplexSession != null)
return new DuplexSessionListenerBinder(duplexSession, messageVersion);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(string.Format(SRServiceModel.UnknownListenerType1, listener.Uri.AbsoluteUri)));
}
// ------------------------------------------------------------------------------------------------------------
// Listener Binders
internal class DuplexListenerBinder : IListenerBinder
{
private IRequestReplyCorrelator _correlator;
private IChannelListener<IDuplexChannel> _listener;
private MessageVersion _messageVersion;
internal DuplexListenerBinder(IChannelListener<IDuplexChannel> listener, MessageVersion messageVersion)
{
_correlator = new RequestReplyCorrelator();
_listener = listener;
_messageVersion = messageVersion;
}
public IChannelListener Listener
{
get { return _listener; }
}
public MessageVersion MessageVersion
{
get { return _messageVersion; }
}
public IChannelBinder Accept(TimeSpan timeout)
{
IDuplexChannel channel = _listener.AcceptChannel(timeout);
if (channel == null)
return null;
return new DuplexChannelBinder(channel, _correlator, _listener.Uri);
}
public IAsyncResult BeginAccept(TimeSpan timeout, AsyncCallback callback, object state)
{
return _listener.BeginAcceptChannel(timeout, callback, state);
}
public IChannelBinder EndAccept(IAsyncResult result)
{
IDuplexChannel channel = _listener.EndAcceptChannel(result);
if (channel == null)
return null;
return new DuplexChannelBinder(channel, _correlator, _listener.Uri);
}
}
internal class DuplexSessionListenerBinder : IListenerBinder
{
private IRequestReplyCorrelator _correlator;
private IChannelListener<IDuplexSessionChannel> _listener;
private MessageVersion _messageVersion;
internal DuplexSessionListenerBinder(IChannelListener<IDuplexSessionChannel> listener, MessageVersion messageVersion)
{
_correlator = new RequestReplyCorrelator();
_listener = listener;
_messageVersion = messageVersion;
}
public IChannelListener Listener
{
get { return _listener; }
}
public MessageVersion MessageVersion
{
get { return _messageVersion; }
}
public IChannelBinder Accept(TimeSpan timeout)
{
IDuplexSessionChannel channel = _listener.AcceptChannel(timeout);
if (channel == null)
return null;
return new DuplexChannelBinder(channel, _correlator, _listener.Uri);
}
public IAsyncResult BeginAccept(TimeSpan timeout, AsyncCallback callback, object state)
{
return _listener.BeginAcceptChannel(timeout, callback, state);
}
public IChannelBinder EndAccept(IAsyncResult result)
{
IDuplexSessionChannel channel = _listener.EndAcceptChannel(result);
if (channel == null)
return null;
return new DuplexChannelBinder(channel, _correlator, _listener.Uri);
}
}
internal class InputListenerBinder : IListenerBinder
{
private IChannelListener<IInputChannel> _listener;
private MessageVersion _messageVersion;
internal InputListenerBinder(IChannelListener<IInputChannel> listener, MessageVersion messageVersion)
{
_listener = listener;
_messageVersion = messageVersion;
}
public IChannelListener Listener
{
get { return _listener; }
}
public MessageVersion MessageVersion
{
get { return _messageVersion; }
}
public IChannelBinder Accept(TimeSpan timeout)
{
IInputChannel channel = _listener.AcceptChannel(timeout);
if (channel == null)
return null;
return new InputChannelBinder(channel, _listener.Uri);
}
public IAsyncResult BeginAccept(TimeSpan timeout, AsyncCallback callback, object state)
{
return _listener.BeginAcceptChannel(timeout, callback, state);
}
public IChannelBinder EndAccept(IAsyncResult result)
{
IInputChannel channel = _listener.EndAcceptChannel(result);
if (channel == null)
return null;
return new InputChannelBinder(channel, _listener.Uri);
}
}
internal class InputSessionListenerBinder : IListenerBinder
{
private IChannelListener<IInputSessionChannel> _listener;
private MessageVersion _messageVersion;
internal InputSessionListenerBinder(IChannelListener<IInputSessionChannel> listener, MessageVersion messageVersion)
{
_listener = listener;
_messageVersion = messageVersion;
}
public IChannelListener Listener
{
get { return _listener; }
}
public MessageVersion MessageVersion
{
get { return _messageVersion; }
}
public IChannelBinder Accept(TimeSpan timeout)
{
IInputSessionChannel channel = _listener.AcceptChannel(timeout);
if (null == channel)
return null;
return new InputChannelBinder(channel, _listener.Uri);
}
public IAsyncResult BeginAccept(TimeSpan timeout, AsyncCallback callback, object state)
{
return _listener.BeginAcceptChannel(timeout, callback, state);
}
public IChannelBinder EndAccept(IAsyncResult result)
{
IInputSessionChannel channel = _listener.EndAcceptChannel(result);
if (channel == null)
return null;
return new InputChannelBinder(channel, _listener.Uri);
}
}
internal class ReplyListenerBinder : IListenerBinder
{
private IChannelListener<IReplyChannel> _listener;
private MessageVersion _messageVersion;
internal ReplyListenerBinder(IChannelListener<IReplyChannel> listener, MessageVersion messageVersion)
{
_listener = listener;
_messageVersion = messageVersion;
}
public IChannelListener Listener
{
get { return _listener; }
}
public MessageVersion MessageVersion
{
get { return _messageVersion; }
}
public IChannelBinder Accept(TimeSpan timeout)
{
IReplyChannel channel = _listener.AcceptChannel(timeout);
if (channel == null)
return null;
return new ReplyChannelBinder(channel, _listener.Uri);
}
public IAsyncResult BeginAccept(TimeSpan timeout, AsyncCallback callback, object state)
{
return _listener.BeginAcceptChannel(timeout, callback, state);
}
public IChannelBinder EndAccept(IAsyncResult result)
{
IReplyChannel channel = _listener.EndAcceptChannel(result);
if (channel == null)
return null;
return new ReplyChannelBinder(channel, _listener.Uri);
}
}
internal class ReplySessionListenerBinder : IListenerBinder
{
private IChannelListener<IReplySessionChannel> _listener;
private MessageVersion _messageVersion;
internal ReplySessionListenerBinder(IChannelListener<IReplySessionChannel> listener, MessageVersion messageVersion)
{
_listener = listener;
_messageVersion = messageVersion;
}
public IChannelListener Listener
{
get { return _listener; }
}
public MessageVersion MessageVersion
{
get { return _messageVersion; }
}
public IChannelBinder Accept(TimeSpan timeout)
{
IReplySessionChannel channel = _listener.AcceptChannel(timeout);
if (channel == null)
return null;
return new ReplyChannelBinder(channel, _listener.Uri);
}
public IAsyncResult BeginAccept(TimeSpan timeout, AsyncCallback callback, object state)
{
return _listener.BeginAcceptChannel(timeout, callback, state);
}
public IChannelBinder EndAccept(IAsyncResult result)
{
IReplySessionChannel channel = _listener.EndAcceptChannel(result);
if (channel == null)
return null;
return new ReplyChannelBinder(channel, _listener.Uri);
}
}
}
}
|