mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
860 lines
29 KiB
C#
860 lines
29 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Dispatcher
|
|
{
|
|
using System;
|
|
using System.Collections.ObjectModel;
|
|
using System.Diagnostics;
|
|
using System.Runtime;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.Diagnostics;
|
|
using System.Security;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Activation;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.Threading;
|
|
using System.Xml;
|
|
using System.Transactions;
|
|
using System.ServiceModel.Diagnostics.Application;
|
|
|
|
delegate void MessageRpcProcessor(ref MessageRpc rpc);
|
|
|
|
struct MessageRpc
|
|
{
|
|
internal readonly ServiceChannel Channel;
|
|
internal readonly ChannelHandler channelHandler;
|
|
internal readonly object[] Correlation;
|
|
internal readonly ServiceHostBase Host;
|
|
internal readonly OperationContext OperationContext;
|
|
internal ServiceModelActivity Activity;
|
|
internal Guid ResponseActivityId;
|
|
internal IAsyncResult AsyncResult;
|
|
internal bool CanSendReply;
|
|
internal bool SuccessfullySendReply;
|
|
internal CorrelationCallbackMessageProperty CorrelationCallback;
|
|
internal object[] InputParameters;
|
|
internal object[] OutputParameters;
|
|
internal object ReturnParameter;
|
|
internal bool ParametersDisposed;
|
|
internal bool DidDeserializeRequestBody;
|
|
internal TransactionMessageProperty TransactionMessageProperty;
|
|
internal TransactedBatchContext TransactedBatchContext;
|
|
internal Exception Error;
|
|
internal MessageRpcProcessor ErrorProcessor;
|
|
internal ErrorHandlerFaultInfo FaultInfo;
|
|
internal bool HasSecurityContext;
|
|
internal object Instance;
|
|
internal bool MessageRpcOwnsInstanceContextThrottle;
|
|
internal MessageRpcProcessor NextProcessor;
|
|
internal Collection<MessageHeaderInfo> NotUnderstoodHeaders;
|
|
internal DispatchOperationRuntime Operation;
|
|
internal Message Request;
|
|
internal RequestContext RequestContext;
|
|
internal bool RequestContextThrewOnReply;
|
|
internal UniqueId RequestID;
|
|
internal Message Reply;
|
|
internal TimeoutHelper ReplyTimeoutHelper;
|
|
internal RequestReplyCorrelator.ReplyToInfo ReplyToInfo;
|
|
internal MessageVersion RequestVersion;
|
|
internal ServiceSecurityContext SecurityContext;
|
|
internal InstanceContext InstanceContext;
|
|
internal bool SuccessfullyBoundInstance;
|
|
internal bool SuccessfullyIncrementedActivity;
|
|
internal bool SuccessfullyLockedInstance;
|
|
internal ReceiveContextRPCFacet ReceiveContext;
|
|
internal TransactionRpcFacet transaction;
|
|
internal IAspNetMessageProperty HostingProperty;
|
|
internal MessageRpcInvokeNotification InvokeNotification;
|
|
internal EventTraceActivity EventTraceActivity;
|
|
|
|
static AsyncCallback handleEndComplete = Fx.ThunkCallback(new AsyncCallback(HandleEndComplete));
|
|
static AsyncCallback handleEndAbandon = Fx.ThunkCallback(new AsyncCallback(HandleEndAbandon));
|
|
|
|
bool paused;
|
|
bool switchedThreads;
|
|
bool isInstanceContextSingleton;
|
|
SignalGate<IAsyncResult> invokeContinueGate;
|
|
|
|
internal MessageRpc(RequestContext requestContext, Message request, DispatchOperationRuntime operation,
|
|
ServiceChannel channel, ServiceHostBase host, ChannelHandler channelHandler, bool cleanThread,
|
|
OperationContext operationContext, InstanceContext instanceContext, EventTraceActivity eventTraceActivity)
|
|
{
|
|
Fx.Assert((operationContext != null), "System.ServiceModel.Dispatcher.MessageRpc.MessageRpc(), operationContext == null");
|
|
Fx.Assert(channelHandler != null, "System.ServiceModel.Dispatcher.MessageRpc.MessageRpc(), channelHandler == null");
|
|
|
|
this.Activity = null;
|
|
this.EventTraceActivity = eventTraceActivity;
|
|
this.AsyncResult = null;
|
|
this.CanSendReply = true;
|
|
this.Channel = channel;
|
|
this.channelHandler = channelHandler;
|
|
this.Correlation = EmptyArray.Allocate(operation.Parent.CorrelationCount);
|
|
this.CorrelationCallback = null;
|
|
this.DidDeserializeRequestBody = false;
|
|
this.TransactionMessageProperty = null;
|
|
this.TransactedBatchContext = null;
|
|
this.Error = null;
|
|
this.ErrorProcessor = null;
|
|
this.FaultInfo = new ErrorHandlerFaultInfo(request.Version.Addressing.DefaultFaultAction);
|
|
this.HasSecurityContext = false;
|
|
this.Host = host;
|
|
this.Instance = null;
|
|
this.MessageRpcOwnsInstanceContextThrottle = false;
|
|
this.NextProcessor = null;
|
|
this.NotUnderstoodHeaders = null;
|
|
this.Operation = operation;
|
|
this.OperationContext = operationContext;
|
|
this.paused = false;
|
|
this.ParametersDisposed = false;
|
|
this.ReceiveContext = null;
|
|
this.Request = request;
|
|
this.RequestContext = requestContext;
|
|
this.RequestContextThrewOnReply = false;
|
|
this.SuccessfullySendReply = false;
|
|
this.RequestVersion = request.Version;
|
|
this.Reply = null;
|
|
this.ReplyTimeoutHelper = new TimeoutHelper();
|
|
this.SecurityContext = null;
|
|
this.InstanceContext = instanceContext;
|
|
this.SuccessfullyBoundInstance = false;
|
|
this.SuccessfullyIncrementedActivity = false;
|
|
this.SuccessfullyLockedInstance = false;
|
|
this.switchedThreads = !cleanThread;
|
|
this.transaction = null;
|
|
this.InputParameters = null;
|
|
this.OutputParameters = null;
|
|
this.ReturnParameter = null;
|
|
this.isInstanceContextSingleton = InstanceContextProviderBase.IsProviderSingleton(this.Channel.DispatchRuntime.InstanceContextProvider);
|
|
this.invokeContinueGate = null;
|
|
|
|
if (!operation.IsOneWay && !operation.Parent.ManualAddressing)
|
|
{
|
|
this.RequestID = request.Headers.MessageId;
|
|
this.ReplyToInfo = new RequestReplyCorrelator.ReplyToInfo(request);
|
|
}
|
|
else
|
|
{
|
|
this.RequestID = null;
|
|
this.ReplyToInfo = new RequestReplyCorrelator.ReplyToInfo();
|
|
}
|
|
|
|
this.HostingProperty = AspNetEnvironment.Current.GetHostingProperty(request, true);
|
|
|
|
if (DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
this.Activity = TraceUtility.ExtractActivity(this.Request);
|
|
}
|
|
|
|
if (DiagnosticUtility.ShouldUseActivity || TraceUtility.ShouldPropagateActivity)
|
|
{
|
|
this.ResponseActivityId = ActivityIdHeader.ExtractActivityId(this.Request);
|
|
}
|
|
else
|
|
{
|
|
this.ResponseActivityId = Guid.Empty;
|
|
}
|
|
|
|
this.InvokeNotification = new MessageRpcInvokeNotification(this.Activity, this.channelHandler);
|
|
|
|
if (this.EventTraceActivity == null && FxTrace.Trace.IsEnd2EndActivityTracingEnabled)
|
|
{
|
|
if (this.Request != null)
|
|
{
|
|
this.EventTraceActivity = EventTraceActivityHelper.TryExtractActivity(this.Request, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal bool FinalizeCorrelationImplicitly
|
|
{
|
|
get { return this.CorrelationCallback != null && this.CorrelationCallback.IsFullyDefined; }
|
|
}
|
|
|
|
internal bool IsPaused
|
|
{
|
|
get { return this.paused; }
|
|
}
|
|
|
|
internal bool SwitchedThreads
|
|
{
|
|
get { return this.switchedThreads; }
|
|
}
|
|
|
|
internal bool IsInstanceContextSingleton
|
|
{
|
|
set
|
|
{
|
|
this.isInstanceContextSingleton = value;
|
|
}
|
|
}
|
|
|
|
internal TransactionRpcFacet Transaction
|
|
{
|
|
get
|
|
{
|
|
if (this.transaction == null)
|
|
{
|
|
this.transaction = new TransactionRpcFacet(ref this);
|
|
}
|
|
return this.transaction;
|
|
}
|
|
}
|
|
|
|
internal void Abort()
|
|
{
|
|
this.AbortRequestContext();
|
|
this.AbortChannel();
|
|
this.AbortInstanceContext();
|
|
}
|
|
|
|
void AbortRequestContext(RequestContext requestContext)
|
|
{
|
|
try
|
|
{
|
|
requestContext.Abort();
|
|
|
|
ReceiveContextRPCFacet receiveContext = this.ReceiveContext;
|
|
|
|
if (receiveContext != null)
|
|
{
|
|
this.ReceiveContext = null;
|
|
IAsyncResult result = receiveContext.BeginAbandon(
|
|
TimeSpan.MaxValue,
|
|
handleEndAbandon,
|
|
new CallbackState
|
|
{
|
|
ReceiveContext = receiveContext,
|
|
ChannelHandler = this.channelHandler
|
|
});
|
|
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
receiveContext.EndAbandon(result);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
this.channelHandler.HandleError(e);
|
|
}
|
|
}
|
|
|
|
internal void AbortRequestContext()
|
|
{
|
|
if (this.OperationContext.RequestContext != null)
|
|
{
|
|
this.AbortRequestContext(this.OperationContext.RequestContext);
|
|
}
|
|
if ((this.RequestContext != null) && (this.RequestContext != this.OperationContext.RequestContext))
|
|
{
|
|
this.AbortRequestContext(this.RequestContext);
|
|
}
|
|
TraceCallDurationInDispatcherIfNecessary(false);
|
|
}
|
|
|
|
void TraceCallDurationInDispatcherIfNecessary(bool requestContextWasClosedSuccessfully)
|
|
{
|
|
// only need to trace once (either for the failure or success case)
|
|
if (TD.DispatchFailedIsEnabled())
|
|
{
|
|
if (requestContextWasClosedSuccessfully)
|
|
{
|
|
TD.DispatchSuccessful(this.EventTraceActivity, this.Operation.Name);
|
|
}
|
|
else
|
|
{
|
|
TD.DispatchFailed(this.EventTraceActivity, this.Operation.Name);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void CloseRequestContext()
|
|
{
|
|
if (this.OperationContext.RequestContext != null)
|
|
{
|
|
this.DisposeRequestContext(this.OperationContext.RequestContext);
|
|
}
|
|
if ((this.RequestContext != null) && (this.RequestContext != this.OperationContext.RequestContext))
|
|
{
|
|
this.DisposeRequestContext(this.RequestContext);
|
|
}
|
|
TraceCallDurationInDispatcherIfNecessary(true);
|
|
}
|
|
|
|
void DisposeRequestContext(RequestContext context)
|
|
{
|
|
try
|
|
{
|
|
context.Close();
|
|
|
|
ReceiveContextRPCFacet receiveContext = this.ReceiveContext;
|
|
|
|
if (receiveContext != null)
|
|
{
|
|
this.ReceiveContext = null;
|
|
IAsyncResult result = receiveContext.BeginComplete(
|
|
TimeSpan.MaxValue,
|
|
null,
|
|
this.channelHandler,
|
|
handleEndComplete,
|
|
new CallbackState
|
|
{
|
|
ChannelHandler = this.channelHandler,
|
|
ReceiveContext = receiveContext
|
|
});
|
|
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
receiveContext.EndComplete(result);
|
|
}
|
|
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
this.AbortRequestContext(context);
|
|
this.channelHandler.HandleError(e);
|
|
}
|
|
}
|
|
|
|
static void HandleEndAbandon(IAsyncResult result)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
|
|
CallbackState callbackState = (CallbackState)result.AsyncState;
|
|
|
|
try
|
|
{
|
|
callbackState.ReceiveContext.EndAbandon(result);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
callbackState.ChannelHandler.HandleError(e);
|
|
}
|
|
}
|
|
|
|
static void HandleEndComplete(IAsyncResult result)
|
|
{
|
|
if (result.CompletedSynchronously)
|
|
{
|
|
return;
|
|
}
|
|
|
|
CallbackState callbackState = (CallbackState)result.AsyncState;
|
|
|
|
try
|
|
{
|
|
callbackState.ReceiveContext.EndComplete(result);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
callbackState.ChannelHandler.HandleError(e);
|
|
}
|
|
}
|
|
|
|
internal void AbortChannel()
|
|
{
|
|
if ((this.Channel != null) && this.Channel.HasSession)
|
|
{
|
|
try
|
|
{
|
|
this.Channel.Abort();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
this.channelHandler.HandleError(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void CloseChannel()
|
|
{
|
|
if ((this.Channel != null) && this.Channel.HasSession)
|
|
{
|
|
try
|
|
{
|
|
this.Channel.Close(ChannelHandler.CloseAfterFaultTimeout);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
this.channelHandler.HandleError(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void AbortInstanceContext()
|
|
{
|
|
if (this.InstanceContext != null && !this.isInstanceContextSingleton)
|
|
{
|
|
try
|
|
{
|
|
this.InstanceContext.Abort();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
this.channelHandler.HandleError(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void EnsureReceive()
|
|
{
|
|
using (ServiceModelActivity.BoundOperation(this.Activity))
|
|
{
|
|
ChannelHandler.Register(this.channelHandler);
|
|
}
|
|
}
|
|
|
|
bool ProcessError(Exception e)
|
|
{
|
|
MessageRpcProcessor handler = this.ErrorProcessor;
|
|
try
|
|
{
|
|
Type exceptionType = e.GetType();
|
|
|
|
if (exceptionType.IsAssignableFrom(typeof(FaultException)))
|
|
{
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Information);
|
|
}
|
|
else
|
|
{
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Error);
|
|
}
|
|
|
|
if (TraceUtility.MessageFlowTracingOnly)
|
|
{
|
|
TraceUtility.SetActivityId(this.Request.Properties);
|
|
if (Guid.Empty == DiagnosticTraceBase.ActivityId)
|
|
{
|
|
Guid receivedActivityId = TraceUtility.ExtractActivityId(this.Request);
|
|
if (Guid.Empty != receivedActivityId)
|
|
{
|
|
DiagnosticTraceBase.ActivityId = receivedActivityId;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
this.Error = e;
|
|
|
|
if (this.ErrorProcessor != null)
|
|
{
|
|
this.ErrorProcessor(ref this);
|
|
}
|
|
|
|
return (this.Error == null);
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e2)
|
|
{
|
|
if (Fx.IsFatal(e2))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
return ((handler != this.ErrorProcessor) && this.ProcessError(e2));
|
|
}
|
|
}
|
|
|
|
internal void DisposeParameters(bool excludeInput)
|
|
{
|
|
if (this.Operation.DisposeParameters)
|
|
{
|
|
this.DisposeParametersCore(excludeInput);
|
|
}
|
|
}
|
|
|
|
internal void DisposeParametersCore(bool excludeInput)
|
|
{
|
|
if (!this.ParametersDisposed)
|
|
{
|
|
if (!excludeInput)
|
|
{
|
|
this.DisposeParameterList(this.InputParameters);
|
|
}
|
|
|
|
this.DisposeParameterList(this.OutputParameters);
|
|
|
|
IDisposable disposableParameter = this.ReturnParameter as IDisposable;
|
|
if (disposableParameter != null)
|
|
{
|
|
try
|
|
{
|
|
disposableParameter.Dispose();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
this.channelHandler.HandleError(e);
|
|
}
|
|
}
|
|
this.ParametersDisposed = true;
|
|
}
|
|
}
|
|
|
|
void DisposeParameterList(object[] parameters)
|
|
{
|
|
IDisposable disposableParameter = null;
|
|
if (parameters != null)
|
|
{
|
|
foreach (Object obj in parameters)
|
|
{
|
|
disposableParameter = obj as IDisposable;
|
|
if (disposableParameter != null)
|
|
{
|
|
try
|
|
{
|
|
disposableParameter.Dispose();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
this.channelHandler.HandleError(e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// See notes on UnPause and Resume (mutually exclusive)
|
|
// Pausing will Increment the BusyCount for the hosting environment
|
|
internal IResumeMessageRpc Pause()
|
|
{
|
|
Wrapper wrapper = new Wrapper(ref this);
|
|
this.paused = true;
|
|
return wrapper;
|
|
}
|
|
|
|
[Fx.Tag.SecurityNote(Critical = "Calls SecurityCritical method ApplyHostingIntegrationContextNoInline. Caller must ensure that"
|
|
+ "function is called appropriately and result is guarded and Dispose()'d correctly.")]
|
|
[SecurityCritical]
|
|
IDisposable ApplyHostingIntegrationContext()
|
|
{
|
|
if (this.HostingProperty != null)
|
|
{
|
|
return this.ApplyHostingIntegrationContextNoInline();
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
[Fx.Tag.SecurityNote(Critical = "Calls SecurityCritical method HostingMessageProperty.ApplyIntegrationContext. Caller must ensure that"
|
|
+ "function is called appropriately and result is guarded and Dispose()'d correctly.")]
|
|
[SecurityCritical]
|
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
|
IDisposable ApplyHostingIntegrationContextNoInline()
|
|
{
|
|
return this.HostingProperty.ApplyIntegrationContext();
|
|
}
|
|
|
|
[Fx.Tag.SecurityNote(Critical = "Calls SecurityCritical method ApplyHostingIntegrationContext.",
|
|
Safe = "Does call properly and calls Dispose, doesn't leak control of the IDisposable out of the function.")]
|
|
[SecuritySafeCritical]
|
|
internal bool Process(bool isOperationContextSet)
|
|
{
|
|
using (ServiceModelActivity.BoundOperation(this.Activity))
|
|
{
|
|
bool completed = true;
|
|
|
|
if (this.NextProcessor != null)
|
|
{
|
|
MessageRpcProcessor processor = this.NextProcessor;
|
|
this.NextProcessor = null;
|
|
|
|
OperationContext originalContext;
|
|
OperationContext.Holder contextHolder;
|
|
if (!isOperationContextSet)
|
|
{
|
|
contextHolder = OperationContext.CurrentHolder;
|
|
originalContext = contextHolder.Context;
|
|
}
|
|
else
|
|
{
|
|
contextHolder = null;
|
|
originalContext = null;
|
|
}
|
|
IncrementBusyCount();
|
|
|
|
IDisposable hostedIntegrationContext = this.ApplyHostingIntegrationContext();
|
|
|
|
try
|
|
{
|
|
if (!isOperationContextSet)
|
|
{
|
|
contextHolder.Context = this.OperationContext;
|
|
}
|
|
|
|
processor(ref this);
|
|
|
|
if (!this.paused)
|
|
{
|
|
this.OperationContext.SetClientReply(null, false);
|
|
}
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
if (!this.ProcessError(e) && this.FaultInfo.Fault == null)
|
|
{
|
|
this.Abort();
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
try
|
|
{
|
|
DecrementBusyCount();
|
|
|
|
if (hostedIntegrationContext != null)
|
|
{
|
|
hostedIntegrationContext.Dispose();
|
|
}
|
|
|
|
if (!isOperationContextSet)
|
|
{
|
|
contextHolder.Context = originalContext;
|
|
}
|
|
|
|
completed = !this.paused;
|
|
if (completed)
|
|
{
|
|
this.channelHandler.DispatchDone();
|
|
this.OperationContext.ClearClientReplyNoThrow();
|
|
}
|
|
}
|
|
#pragma warning suppress 56500 // covered by FxCOP
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
{
|
|
throw;
|
|
}
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperFatal(e.Message, e);
|
|
}
|
|
}
|
|
}
|
|
|
|
return completed;
|
|
}
|
|
}
|
|
|
|
// UnPause is called on the original MessageRpc to continue work on the current thread, and the copy is ignored.
|
|
// Since the copy is ignored, Decrement the BusyCount
|
|
internal void UnPause()
|
|
{
|
|
this.paused = false;
|
|
DecrementBusyCount();
|
|
|
|
}
|
|
|
|
internal bool UnlockInvokeContinueGate(out IAsyncResult result)
|
|
{
|
|
return this.invokeContinueGate.Unlock(out result);
|
|
}
|
|
|
|
internal void PrepareInvokeContinueGate()
|
|
{
|
|
this.invokeContinueGate = new SignalGate<IAsyncResult>();
|
|
}
|
|
|
|
void IncrementBusyCount()
|
|
{
|
|
// Only increment the counter on the service side.
|
|
if (this.Host != null)
|
|
{
|
|
this.Host.IncrementBusyCount();
|
|
if (AspNetEnvironment.Current.TraceIncrementBusyCountIsEnabled())
|
|
{
|
|
AspNetEnvironment.Current.TraceIncrementBusyCount(SR.GetString(SR.ServiceBusyCountTrace, this.Operation.Action));
|
|
}
|
|
}
|
|
}
|
|
|
|
void DecrementBusyCount()
|
|
{
|
|
if (this.Host != null)
|
|
{
|
|
this.Host.DecrementBusyCount();
|
|
if (AspNetEnvironment.Current.TraceDecrementBusyCountIsEnabled())
|
|
{
|
|
AspNetEnvironment.Current.TraceDecrementBusyCount(SR.GetString(SR.ServiceBusyCountTrace, this.Operation.Action));
|
|
}
|
|
}
|
|
}
|
|
|
|
class CallbackState
|
|
{
|
|
public ReceiveContextRPCFacet ReceiveContext
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public ChannelHandler ChannelHandler
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
}
|
|
|
|
class Wrapper : IResumeMessageRpc
|
|
{
|
|
MessageRpc rpc;
|
|
bool alreadyResumed;
|
|
|
|
internal Wrapper(ref MessageRpc rpc)
|
|
{
|
|
this.rpc = rpc;
|
|
if (rpc.NextProcessor == null)
|
|
{
|
|
Fx.Assert("MessageRpc.Wrapper.Wrapper: (rpc.NextProcessor != null)");
|
|
}
|
|
this.rpc.IncrementBusyCount();
|
|
|
|
}
|
|
|
|
public InstanceContext GetMessageInstanceContext()
|
|
{
|
|
return this.rpc.InstanceContext;
|
|
}
|
|
|
|
// Resume is called on the copy on some completing thread, whereupon work continues on that thread.
|
|
// BusyCount is Decremented as the copy is now complete
|
|
public void Resume(out bool alreadyResumedNoLock)
|
|
{
|
|
try
|
|
{
|
|
alreadyResumedNoLock = this.alreadyResumed;
|
|
this.alreadyResumed = true;
|
|
|
|
this.rpc.switchedThreads = true;
|
|
if (this.rpc.Process(false) && !rpc.InvokeNotification.DidInvokerEnsurePump)
|
|
{
|
|
this.rpc.EnsureReceive();
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
this.rpc.DecrementBusyCount();
|
|
|
|
}
|
|
}
|
|
|
|
public void Resume(IAsyncResult result)
|
|
{
|
|
this.rpc.AsyncResult = result;
|
|
this.Resume();
|
|
}
|
|
|
|
public void Resume(object instance)
|
|
{
|
|
this.rpc.Instance = instance;
|
|
this.Resume();
|
|
}
|
|
|
|
public void Resume()
|
|
{
|
|
using (ServiceModelActivity.BoundOperation(this.rpc.Activity, true))
|
|
{
|
|
bool alreadyResumedNoLock;
|
|
this.Resume(out alreadyResumedNoLock);
|
|
if (alreadyResumedNoLock)
|
|
{
|
|
string text = SR.GetString(SR.SFxMultipleCallbackFromAsyncOperation, rpc.Operation.Name);
|
|
Exception error = new InvalidOperationException(text);
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(error);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SignalConditionalResume(IAsyncResult result)
|
|
{
|
|
if (this.rpc.invokeContinueGate.Signal(result))
|
|
{
|
|
this.rpc.AsyncResult = result;
|
|
Resume();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
class MessageRpcInvokeNotification : IInvokeReceivedNotification
|
|
{
|
|
ServiceModelActivity activity;
|
|
ChannelHandler handler;
|
|
|
|
public MessageRpcInvokeNotification(ServiceModelActivity activity, ChannelHandler handler)
|
|
{
|
|
this.activity = activity;
|
|
this.handler = handler;
|
|
}
|
|
|
|
public bool DidInvokerEnsurePump { get; set; }
|
|
|
|
public void NotifyInvokeReceived()
|
|
{
|
|
using (ServiceModelActivity.BoundOperation(this.activity))
|
|
{
|
|
ChannelHandler.Register(this.handler);
|
|
}
|
|
this.DidInvokerEnsurePump = true;
|
|
}
|
|
|
|
public void NotifyInvokeReceived(RequestContext request)
|
|
{
|
|
using (ServiceModelActivity.BoundOperation(this.activity))
|
|
{
|
|
ChannelHandler.Register(this.handler, request);
|
|
}
|
|
this.DidInvokerEnsurePump = true;
|
|
}
|
|
}
|
|
}
|