private void Dispatch()
{
ListenerChannel channel = _channel;
SessionIdleManager idleManager = _idleManager;
_channel = null;
_idleManager = null;
try
{
if (channel != null)
{
ChannelHandler handler = new ChannelHandler(_listenerBinder.MessageVersion, channel.Binder, this, idleManager);
if (!channel.Binder.HasSession)
{
_channelDispatcher.Channels.Add(channel.Binder.Channel);
}
if (channel.Binder is DuplexChannelBinder)
{
DuplexChannelBinder duplexChannelBinder = channel.Binder as DuplexChannelBinder;
duplexChannelBinder.ChannelHandler = handler;
duplexChannelBinder.DefaultCloseTimeout = this.DefaultCloseTimeout;
if (_timeouts == null)
{
duplexChannelBinder.DefaultSendTimeout = ServiceDefaults.SendTimeout;
}
else
{
duplexChannelBinder.DefaultSendTimeout = _timeouts.SendTimeout;
}
}
ChannelHandler.Register(handler);
channel = null;
idleManager = null;
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
this.HandleError(e);
}
finally
{
if (channel != null)
{
channel.Binder.Channel.Abort();
if (idleManager != null)
{
idleManager.CancelTimer();
}
}
}
}
internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder, ServiceChannel channel)
{
ClientRuntime clientRuntime = channel.ClientRuntime;
_messageVersion = messageVersion;
_isManualAddressing = clientRuntime.ManualAddressing;
_binder = binder;
_channel = channel;
_isConcurrent = true;
_duplexBinder = binder as DuplexChannelBinder;
_hasSession = binder.HasSession;
_isCallback = true;
DispatchRuntime dispatchRuntime = clientRuntime.DispatchRuntime;
if (dispatchRuntime == null)
{
_receiver = new ErrorHandlingReceiver(binder, null);
}
else
{
_receiver = new ErrorHandlingReceiver(binder, dispatchRuntime.ChannelDispatcher);
}
_requestInfo = new RequestInfo(this);
}
internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder, ServiceChannel channel)
{
ClientRuntime clientRuntime = channel.ClientRuntime;
this.messageVersion = messageVersion;
this.isManualAddressing = clientRuntime.ManualAddressing;
this.binder = binder;
this.channel = channel;
this.isConcurrent = true;
this.duplexBinder = binder as DuplexChannelBinder;
this.hasSession = binder.HasSession;
this.isCallback = true;
DispatchRuntime dispatchRuntime = clientRuntime.DispatchRuntime;
if (dispatchRuntime == null)
{
this.receiver = new ErrorHandlingReceiver(binder, null);
}
else
{
this.receiver = new ErrorHandlingReceiver(binder, dispatchRuntime.ChannelDispatcher);
}
this.requestInfo = new RequestInfo(this);
}
private void Dispatch()
{
ListenerChannel channel = this.channel;
ServiceChannel.SessionIdleManager idleManager = this.idleManager;
this.channel = null;
this.idleManager = null;
try
{
if (channel != null)
{
ChannelHandler handler = new ChannelHandler(this.listenerBinder.MessageVersion, channel.Binder, this.throttle, this, channel.Throttle != null, this.wrappedTransaction, idleManager);
if (!channel.Binder.HasSession)
{
this.channelDispatcher.Channels.Add(channel.Binder.Channel);
}
if (channel.Binder is DuplexChannelBinder)
{
DuplexChannelBinder binder = channel.Binder as DuplexChannelBinder;
binder.ChannelHandler = handler;
binder.DefaultCloseTimeout = this.DefaultCloseTimeout;
if (this.timeouts == null)
{
binder.DefaultSendTimeout = ServiceDefaults.SendTimeout;
}
else
{
binder.DefaultSendTimeout = this.timeouts.SendTimeout;
}
}
ChannelHandler.Register(handler);
channel = null;
idleManager = null;
}
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
this.HandleError(exception);
}
finally
{
if (channel != null)
{
channel.Binder.Channel.Abort();
if ((this.throttle != null) && this.channelDispatcher.Session)
{
this.throttle.DeactivateChannel();
}
if (idleManager != null)
{
idleManager.CancelTimer();
}
}
}
}
internal AsyncDuplexRequest(Message message, DuplexChannelBinder parent, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state)
{
this.parent = parent;
this.timeout = timeout;
if (timeout != TimeSpan.MaxValue)
{
this.timer = new IOThreadTimer(timerCallback, this, true);
this.timer.Set(timeout);
}
if (DiagnosticUtility.ShouldUseActivity)
{
this.activity = TraceUtility.ExtractActivity(message);
}
}
internal ChannelHandler(ChannelHandler handler, TransactedBatchContext context)
{
this.messageVersion = handler.messageVersion;
this.isManualAddressing = handler.isManualAddressing;
this.binder = handler.binder;
this.listener = handler.listener;
this.wasChannelThrottled = handler.wasChannelThrottled;
this.host = handler.host;
this.receiveSynchronously = true;
this.receiveWithTransaction = true;
this.duplexBinder = handler.duplexBinder;
this.hasSession = handler.hasSession;
this.isConcurrent = handler.isConcurrent;
this.receiver = handler.receiver;
this.sharedTransactedBatchContext = context.Shared;
this.transactedBatchContext = context;
this.requestInfo = new RequestInfo(this);
}
internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder,
ListenerHandler listener, SessionIdleManager idleManager)
{
ChannelDispatcher channelDispatcher = listener.ChannelDispatcher;
_messageVersion = messageVersion;
_isManualAddressing = channelDispatcher.ManualAddressing;
_binder = binder;
_listener = listener;
_receiveSynchronously = channelDispatcher.ReceiveSynchronously;
_sendAsynchronously = channelDispatcher.SendAsynchronously;
_duplexBinder = binder as DuplexChannelBinder;
_hasSession = binder.HasSession;
_isConcurrent = ConcurrencyBehavior.IsConcurrent(channelDispatcher, _hasSession);
if (channelDispatcher.MaxPendingReceives > 1)
{
throw NotImplemented.ByDesign;
}
if (channelDispatcher.BufferedReceiveEnabled)
{
_binder = new BufferedReceiveBinder(_binder);
}
_receiver = new ErrorHandlingReceiver(_binder, channelDispatcher);
_idleManager = idleManager;
Fx.Assert((_idleManager != null) == (_binder.HasSession && _listener.ChannelDispatcher.DefaultCommunicationTimeouts.ReceiveTimeout != TimeSpan.MaxValue), "idle manager is present only when there is a session with a finite receive timeout");
_requestInfo = new RequestInfo(this);
if (_listener.State == CommunicationState.Opened)
{
_listener.ChannelDispatcher.Channels.IncrementActivityCount();
_incrementedActivityCountInConstructor = true;
}
}
internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder, ServiceThrottle throttle,
ListenerHandler listener, bool wasChannelThrottled, WrappedTransaction acceptTransaction, SessionIdleManager idleManager)
{
ChannelDispatcher channelDispatcher = listener.ChannelDispatcher;
this.messageVersion = messageVersion;
this.isManualAddressing = channelDispatcher.ManualAddressing;
this.binder = binder;
this.throttle = throttle;
this.listener = listener;
this.wasChannelThrottled = wasChannelThrottled;
this.host = listener.Host;
this.receiveSynchronously = channelDispatcher.ReceiveSynchronously;
this.sendAsynchronously = channelDispatcher.SendAsynchronously;
this.duplexBinder = binder as DuplexChannelBinder;
this.hasSession = binder.HasSession;
this.isConcurrent = ConcurrencyBehavior.IsConcurrent(channelDispatcher, this.hasSession);
if (channelDispatcher.MaxPendingReceives > 1)
{
// We need to preserve order if the ChannelHandler is not concurrent.
this.binder = new MultipleReceiveBinder(
this.binder,
channelDispatcher.MaxPendingReceives,
!this.isConcurrent);
}
if (channelDispatcher.BufferedReceiveEnabled)
{
this.binder = new BufferedReceiveBinder(this.binder);
}
this.receiver = new ErrorHandlingReceiver(this.binder, channelDispatcher);
this.idleManager = idleManager;
Fx.Assert((this.idleManager != null) == (this.binder.HasSession && this.listener.ChannelDispatcher.DefaultCommunicationTimeouts.ReceiveTimeout != TimeSpan.MaxValue), "idle manager is present only when there is a session with a finite receive timeout");
if (channelDispatcher.IsTransactedReceive && !channelDispatcher.ReceiveContextEnabled)
{
receiveSynchronously = true;
receiveWithTransaction = true;
if (channelDispatcher.MaxTransactedBatchSize > 0)
{
int maxConcurrentBatches = 1;
if (null != throttle && throttle.MaxConcurrentCalls > 1)
{
maxConcurrentBatches = throttle.MaxConcurrentCalls;
foreach (EndpointDispatcher endpointDispatcher in channelDispatcher.Endpoints)
{
if (ConcurrencyMode.Multiple != endpointDispatcher.DispatchRuntime.ConcurrencyMode)
{
maxConcurrentBatches = 1;
break;
}
}
}
this.sharedTransactedBatchContext = new SharedTransactedBatchContext(this, channelDispatcher, maxConcurrentBatches);
this.isMainTransactedBatchHandler = true;
this.throttle = null;
}
}
else if (channelDispatcher.IsTransactedReceive && channelDispatcher.ReceiveContextEnabled && channelDispatcher.MaxTransactedBatchSize > 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.IncompatibleBehaviors)));
}
if (this.binder.HasSession)
{
this.sessionOpenNotification = this.binder.Channel.GetProperty<SessionOpenNotification>();
this.needToCreateSessionOpenNotificationMessage = this.sessionOpenNotification != null && this.sessionOpenNotification.IsEnabled;
}
this.acceptTransaction = acceptTransaction;
this.requestInfo = new RequestInfo(this);
if (this.listener.State == CommunicationState.Opened)
{
this.listener.ChannelDispatcher.Channels.IncrementActivityCount();
this.incrementedActivityCountInConstructor = true;
}
}
internal ChannelHandler(ChannelHandler handler, TransactedBatchContext context)
{
this.messageVersion = handler.messageVersion;
this.isManualAddressing = handler.isManualAddressing;
this.binder = handler.binder;
this.listener = handler.listener;
this.wasChannelThrottled = handler.wasChannelThrottled;
this.host = handler.host;
this.receiveSynchronously = true;
this.receiveWithTransaction = true;
this.duplexBinder = handler.duplexBinder;
this.hasSession = handler.hasSession;
this.isConcurrent = handler.isConcurrent;
this.receiver = handler.receiver;
this.sharedTransactedBatchContext = context.Shared;
this.transactedBatchContext = context;
this.requestInfo = new RequestInfo(this);
this.sendAsynchronously = handler.sendAsynchronously;
this.sessionOpenNotification = handler.sessionOpenNotification;
this.needToCreateSessionOpenNotificationMessage = handler.needToCreateSessionOpenNotificationMessage;
this.shouldRejectMessageWithOnOpenActionHeader = handler.shouldRejectMessageWithOnOpenActionHeader;
}
internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder,
ListenerHandler listener, SessionIdleManager idleManager)
{
ChannelDispatcher channelDispatcher = listener.ChannelDispatcher;
_messageVersion = messageVersion;
_isManualAddressing = channelDispatcher.ManualAddressing;
_binder = binder;
_listener = listener;
_receiveSynchronously = channelDispatcher.ReceiveSynchronously;
_sendAsynchronously = channelDispatcher.SendAsynchronously;
_duplexBinder = binder as DuplexChannelBinder;
_hasSession = binder.HasSession;
_isConcurrent = ConcurrencyBehavior.IsConcurrent(channelDispatcher, _hasSession);
if (channelDispatcher.MaxPendingReceives > 1)
{
throw NotImplemented.ByDesign;
}
if (channelDispatcher.BufferedReceiveEnabled)
{
_binder = new BufferedReceiveBinder(_binder);
}
_receiver = new ErrorHandlingReceiver(_binder, channelDispatcher);
_idleManager = idleManager;
Fx.Assert((_idleManager != null) == (_binder.HasSession && _listener.ChannelDispatcher.DefaultCommunicationTimeouts.ReceiveTimeout != TimeSpan.MaxValue), "idle manager is present only when there is a session with a finite receive timeout");
_requestInfo = new RequestInfo(this);
if (_listener.State == CommunicationState.Opened)
{
_listener.ChannelDispatcher.Channels.IncrementActivityCount();
_incrementedActivityCountInConstructor = true;
}
}
internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder, ServiceThrottle throttle, ListenerHandler listener, bool wasChannelThrottled, WrappedTransaction acceptTransaction, ServiceChannel.SessionIdleManager idleManager)
{
ChannelDispatcher channelDispatcher = listener.ChannelDispatcher;
this.messageVersion = messageVersion;
this.isManualAddressing = channelDispatcher.ManualAddressing;
this.binder = binder;
this.throttle = throttle;
this.listener = listener;
this.wasChannelThrottled = wasChannelThrottled;
this.host = listener.Host;
this.receiveSynchronously = channelDispatcher.ReceiveSynchronously;
this.duplexBinder = binder as DuplexChannelBinder;
this.hasSession = binder.HasSession;
this.isConcurrent = ConcurrencyBehavior.IsConcurrent(channelDispatcher, this.hasSession);
if (channelDispatcher.MaxPendingReceives > 1)
{
this.binder = new MultipleReceiveBinder(this.binder, channelDispatcher.MaxPendingReceives, !this.isConcurrent);
}
if (channelDispatcher.BufferedReceiveEnabled)
{
this.binder = new BufferedReceiveBinder(this.binder);
}
this.receiver = new ErrorHandlingReceiver(this.binder, channelDispatcher);
this.idleManager = idleManager;
if (!channelDispatcher.IsTransactedReceive || channelDispatcher.ReceiveContextEnabled)
{
if ((channelDispatcher.IsTransactedReceive && channelDispatcher.ReceiveContextEnabled) && (channelDispatcher.MaxTransactedBatchSize > 0))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("IncompatibleBehaviors")));
}
}
else
{
this.receiveSynchronously = true;
this.receiveWithTransaction = true;
if (channelDispatcher.MaxTransactedBatchSize > 0)
{
int maxConcurrentBatches = 1;
if ((throttle != null) && (throttle.MaxConcurrentCalls > 1))
{
maxConcurrentBatches = throttle.MaxConcurrentCalls;
foreach (EndpointDispatcher dispatcher2 in channelDispatcher.Endpoints)
{
if (ConcurrencyMode.Multiple != dispatcher2.DispatchRuntime.ConcurrencyMode)
{
maxConcurrentBatches = 1;
break;
}
}
}
this.sharedTransactedBatchContext = new SharedTransactedBatchContext(this, channelDispatcher, maxConcurrentBatches);
this.isMainTransactedBatchHandler = true;
this.throttle = null;
}
}
this.acceptTransaction = acceptTransaction;
this.requestInfo = new RequestInfo(this);
if (!this.hasSession && (this.listener.State == CommunicationState.Opened))
{
this.listener.ChannelDispatcher.Channels.IncrementActivityCount();
this.incrementedActivityCountInConstructor = true;
}
}
internal SyncDuplexRequest(DuplexChannelBinder parent)
{
this.parent = parent;
}
internal DuplexRequestContext(IDuplexChannel channel, Message request, DuplexChannelBinder binder) : base(request, binder.DefaultCloseTimeout, binder.DefaultSendTimeout)
{
this.channel = channel;
this.binder = binder;
}