internal static void UnlockInstanceBeforeCallout(OperationContext operationContext)
{
if (operationContext != null && operationContext.IsServiceReentrant)
{
ConcurrencyBehavior.UnlockInstance(operationContext.InstanceContext);
}
}
internal static bool IsConcurrent(ChannelDispatcher runtime, bool hasSession)
{
bool isConcurrencyModeSingle = true;
if (ConcurrencyBehavior.SupportsTransactedBatch(runtime))
{
return(false);
}
foreach (EndpointDispatcher endpointDispatcher in runtime.Endpoints)
{
if (endpointDispatcher.DispatchRuntime.EnsureOrderedDispatch)
{
return(false);
}
if (endpointDispatcher.DispatchRuntime.ConcurrencyMode != ConcurrencyMode.Single)
{
isConcurrencyModeSingle = false;
}
}
if (!isConcurrencyModeSingle)
{
return(true);
}
if (!hasSession)
{
return(true);
}
return(false);
}
internal void UnlockInstance(ref MessageRpc rpc)
{
if (_concurrencyMode != ConcurrencyMode.Multiple)
{
ConcurrencyBehavior.UnlockInstance(rpc.InstanceContext);
}
}
internal ImmutableDispatchRuntime(DispatchRuntime dispatch)
{
_concurrency = new ConcurrencyBehavior(dispatch);
_error = new ErrorBehavior(dispatch.ChannelDispatcher);
EnableFaults = dispatch.EnableFaults;
_instance = new InstanceBehavior(dispatch, this);
ManualAddressing = dispatch.ManualAddressing;
_messageInspectors = EmptyArray <IDispatchMessageInspector> .ToArray(dispatch.MessageInspectors);
_terminate = TerminatingOperationBehavior.CreateIfNecessary(dispatch);
_thread = new ThreadBehavior(dispatch);
_sendAsynchronously = dispatch.ChannelDispatcher.SendAsynchronously;
CorrelationCount = dispatch.MaxParameterInspectors;
DispatchOperationRuntime unhandled = new DispatchOperationRuntime(dispatch.UnhandledDispatchOperation, this);
ActionDemuxer demuxer = new ActionDemuxer();
for (int i = 0; i < dispatch.Operations.Count; i++)
{
DispatchOperation operation = dispatch.Operations[i];
DispatchOperationRuntime operationRuntime = new DispatchOperationRuntime(operation, this);
demuxer.Add(operation.Action, operationRuntime);
}
demuxer.SetUnhandled(unhandled);
_demuxer = demuxer;
_processMessage1 = ProcessMessage1;
_processMessage11 = ProcessMessage11;
_processMessage2 = ProcessMessage2;
_processMessage3 = ProcessMessage3;
_processMessage31 = ProcessMessage31;
_processMessage4 = ProcessMessage4;
_processMessage41 = ProcessMessage41;
_processMessage5 = ProcessMessage5;
_processMessage6 = ProcessMessage6;
_processMessage7 = ProcessMessage7;
_processMessage8 = ProcessMessage8;
_processMessage9 = ProcessMessage9;
_processMessageCleanup = ProcessMessageCleanup;
_processMessageCleanupError = ProcessMessageCleanupError;
}
internal ImmutableDispatchRuntime(DispatchRuntime dispatch)
{
_concurrency = new ConcurrencyBehavior(dispatch);
_error = new ErrorBehavior(dispatch.ChannelDispatcher);
_enableFaults = dispatch.EnableFaults;
_instance = new InstanceBehavior(dispatch, this);
_manualAddressing = dispatch.ManualAddressing;
_thread = new ThreadBehavior(dispatch);
_sendAsynchronously = dispatch.ChannelDispatcher.SendAsynchronously;
_correlationCount = dispatch.MaxParameterInspectors;
DispatchOperationRuntime unhandled = new DispatchOperationRuntime(dispatch.UnhandledDispatchOperation, this);
ActionDemuxer demuxer = new ActionDemuxer();
for (int i = 0; i < dispatch.Operations.Count; i++)
{
DispatchOperation operation = dispatch.Operations[i];
DispatchOperationRuntime operationRuntime = new DispatchOperationRuntime(operation, this);
demuxer.Add(operation.Action, operationRuntime);
}
demuxer.SetUnhandled(unhandled);
_demuxer = demuxer;
_processMessage1 = ProcessMessage1;
_processMessage11 = ProcessMessage11;
_processMessage2 = ProcessMessage2;
_processMessage3 = ProcessMessage3;
_processMessage31 = ProcessMessage31;
_processMessage4 = ProcessMessage4;
_processMessage41 = ProcessMessage41;
_processMessage5 = ProcessMessage5;
_processMessage6 = ProcessMessage6;
_processMessage7 = ProcessMessage7;
_processMessage8 = ProcessMessage8;
_processMessage9 = ProcessMessage9;
_processMessageCleanup = ProcessMessageCleanup;
_processMessageCleanupError = ProcessMessageCleanupError;
}
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 ImmutableDispatchRuntime(DispatchRuntime dispatch)
{
this.authenticationBehavior = AuthenticationBehavior.TryCreate(dispatch);
this.authorizationBehavior = AuthorizationBehavior.TryCreate(dispatch);
this.concurrency = new ConcurrencyBehavior(dispatch);
this.error = new ErrorBehavior(dispatch.ChannelDispatcher);
this.enableFaults = dispatch.EnableFaults;
this.inputSessionShutdownHandlers = EmptyArray<IInputSessionShutdown>.ToArray(dispatch.InputSessionShutdownHandlers);
this.instance = new InstanceBehavior(dispatch, this);
this.isOnServer = dispatch.IsOnServer;
this.manualAddressing = dispatch.ManualAddressing;
this.messageInspectors = EmptyArray<IDispatchMessageInspector>.ToArray(dispatch.MessageInspectors);
this.requestReplyCorrelator = new RequestReplyCorrelator();
this.securityImpersonation = SecurityImpersonationBehavior.CreateIfNecessary(dispatch);
this.requireClaimsPrincipalOnOperationContext = dispatch.RequireClaimsPrincipalOnOperationContext;
this.impersonateOnSerializingReply = dispatch.ImpersonateOnSerializingReply;
this.terminate = TerminatingOperationBehavior.CreateIfNecessary(dispatch);
this.thread = new ThreadBehavior(dispatch);
this.validateMustUnderstand = dispatch.ValidateMustUnderstand;
this.ignoreTransactionFlow = dispatch.IgnoreTransactionMessageProperty;
this.transaction = TransactionBehavior.CreateIfNeeded(dispatch);
this.receiveContextEnabledChannel = dispatch.ChannelDispatcher.ReceiveContextEnabled;
this.sendAsynchronously = dispatch.ChannelDispatcher.SendAsynchronously;
this.parameterInspectorCorrelationOffset = (dispatch.MessageInspectors.Count +
dispatch.MaxCallContextInitializers);
this.correlationCount = this.parameterInspectorCorrelationOffset + dispatch.MaxParameterInspectors;
DispatchOperationRuntime unhandled = new DispatchOperationRuntime(dispatch.UnhandledDispatchOperation, this);
if (dispatch.OperationSelector == null)
{
ActionDemuxer demuxer = new ActionDemuxer();
for (int i = 0; i < dispatch.Operations.Count; i++)
{
DispatchOperation operation = dispatch.Operations[i];
DispatchOperationRuntime operationRuntime = new DispatchOperationRuntime(operation, this);
demuxer.Add(operation.Action, operationRuntime);
}
demuxer.SetUnhandled(unhandled);
this.demuxer = demuxer;
}
else
{
CustomDemuxer demuxer = new CustomDemuxer(dispatch.OperationSelector);
for (int i = 0; i < dispatch.Operations.Count; i++)
{
DispatchOperation operation = dispatch.Operations[i];
DispatchOperationRuntime operationRuntime = new DispatchOperationRuntime(operation, this);
demuxer.Add(operation.Name, operationRuntime);
}
demuxer.SetUnhandled(unhandled);
this.demuxer = demuxer;
}
this.processMessage1 = new MessageRpcProcessor(this.ProcessMessage1);
this.processMessage11 = new MessageRpcProcessor(this.ProcessMessage11);
this.processMessage2 = new MessageRpcProcessor(this.ProcessMessage2);
this.processMessage3 = new MessageRpcProcessor(this.ProcessMessage3);
this.processMessage31 = new MessageRpcProcessor(this.ProcessMessage31);
this.processMessage4 = new MessageRpcProcessor(this.ProcessMessage4);
this.processMessage41 = new MessageRpcProcessor(this.ProcessMessage41);
this.processMessage5 = new MessageRpcProcessor(this.ProcessMessage5);
this.processMessage6 = new MessageRpcProcessor(this.ProcessMessage6);
this.processMessage7 = new MessageRpcProcessor(this.ProcessMessage7);
this.processMessage8 = new MessageRpcProcessor(this.ProcessMessage8);
this.processMessage9 = new MessageRpcProcessor(this.ProcessMessage9);
this.processMessageCleanup = new MessageRpcProcessor(this.ProcessMessageCleanup);
this.processMessageCleanupError = new MessageRpcProcessor(this.ProcessMessageCleanupError);
}
internal void EnqueueCalloutMessage(ConcurrencyBehavior.IWaiter waiter)
{
if (_calloutMessageQueue == null)
_calloutMessageQueue = new Queue<ConcurrencyBehavior.IWaiter>();
_calloutMessageQueue.Enqueue(waiter);
}
internal void EnqueueNewMessage(ConcurrencyBehavior.IWaiter waiter)
{
if (_newMessageQueue == null)
_newMessageQueue = new Queue<ConcurrencyBehavior.IWaiter>();
_newMessageQueue.Enqueue(waiter);
}
internal ConcurrencyBehavior(DispatchRuntime runtime)
{
this.concurrencyMode = runtime.ConcurrencyMode;
this.enforceOrderedReceive = runtime.EnsureOrderedDispatch;
this.supportsTransactedBatch = ConcurrencyBehavior.SupportsTransactedBatch(runtime.ChannelDispatcher);
}