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
389 lines
15 KiB
C#
389 lines
15 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Dispatcher
|
|
{
|
|
using System;
|
|
using System.Diagnostics;
|
|
using System.Reflection;
|
|
using System.Runtime.Diagnostics;
|
|
using System.Security;
|
|
using System.ServiceModel.Description;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.ServiceModel.Diagnostics.Application;
|
|
using System.Runtime;
|
|
|
|
class AsyncMethodInvoker : IOperationInvoker
|
|
{
|
|
MethodInfo beginMethod;
|
|
MethodInfo endMethod;
|
|
InvokeBeginDelegate invokeBeginDelegate;
|
|
InvokeEndDelegate invokeEndDelegate;
|
|
int inputParameterCount;
|
|
int outputParameterCount;
|
|
|
|
public AsyncMethodInvoker(MethodInfo beginMethod, MethodInfo endMethod)
|
|
{
|
|
if (beginMethod == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("beginMethod"));
|
|
if (endMethod == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("endMethod"));
|
|
|
|
this.beginMethod = beginMethod;
|
|
this.endMethod = endMethod;
|
|
}
|
|
|
|
public MethodInfo BeginMethod
|
|
{
|
|
get { return this.beginMethod; }
|
|
}
|
|
|
|
public MethodInfo EndMethod
|
|
{
|
|
get { return this.endMethod; }
|
|
}
|
|
|
|
public bool IsSynchronous
|
|
{
|
|
get { return false; }
|
|
}
|
|
|
|
public object[] AllocateInputs()
|
|
{
|
|
return EmptyArray.Allocate(this.InputParameterCount);
|
|
}
|
|
|
|
public object Invoke(object instance, object[] inputs, out object[] outputs)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
|
|
}
|
|
|
|
internal static void CreateActivityInfo(ref ServiceModelActivity activity, ref Activity boundActivity)
|
|
{
|
|
if (DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
activity = ServiceModelActivity.CreateAsyncActivity();
|
|
TraceUtility.UpdateAsyncOperationContextWithActivity(activity);
|
|
boundActivity = ServiceModelActivity.BoundOperation(activity, true);
|
|
}
|
|
else if (TraceUtility.MessageFlowTracingOnly)
|
|
{
|
|
Guid activityId = TraceUtility.GetReceivedActivityId(OperationContext.Current);
|
|
if (activityId != Guid.Empty)
|
|
{
|
|
DiagnosticTraceBase.ActivityId = activityId;
|
|
}
|
|
}
|
|
else if (TraceUtility.ShouldPropagateActivity)
|
|
{
|
|
//Message flow tracing only scenarios use a light-weight ActivityID management logic
|
|
Guid activityId = ActivityIdHeader.ExtractActivityId(OperationContext.Current.IncomingMessage);
|
|
if (activityId != Guid.Empty)
|
|
{
|
|
boundActivity = Activity.CreateActivity(activityId);
|
|
}
|
|
TraceUtility.UpdateAsyncOperationContextWithActivity(activityId);
|
|
}
|
|
}
|
|
|
|
public IAsyncResult InvokeBegin(object instance, object[] inputs, AsyncCallback callback, object state)
|
|
{
|
|
if (instance == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxNoServiceObject)));
|
|
if (inputs == null)
|
|
{
|
|
if (this.InputParameterCount > 0)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxInputParametersToServiceNull, this.InputParameterCount)));
|
|
}
|
|
else if (inputs.Length != this.InputParameterCount)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxInputParametersToServiceInvalid, this.InputParameterCount, inputs.Length)));
|
|
|
|
StartOperationInvokePerformanceCounters(this.beginMethod.Name.Substring(ServiceReflector.BeginMethodNamePrefix.Length));
|
|
|
|
IAsyncResult returnValue;
|
|
bool callFailed = true;
|
|
bool callFaulted = false;
|
|
ServiceModelActivity activity = null;
|
|
try
|
|
{
|
|
Activity boundActivity = null;
|
|
CreateActivityInfo(ref activity, ref boundActivity);
|
|
|
|
StartOperationInvokeTrace(this.beginMethod.Name);
|
|
|
|
using (boundActivity)
|
|
{
|
|
if (DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
string activityName = null;
|
|
|
|
if (this.endMethod == null)
|
|
{
|
|
activityName = SR.GetString(SR.ActivityExecuteMethod,
|
|
this.beginMethod.DeclaringType.FullName, this.beginMethod.Name);
|
|
}
|
|
else
|
|
{
|
|
activityName = SR.GetString(SR.ActivityExecuteAsyncMethod,
|
|
this.beginMethod.DeclaringType.FullName, this.beginMethod.Name,
|
|
this.endMethod.DeclaringType.FullName, this.endMethod.Name);
|
|
}
|
|
|
|
ServiceModelActivity.Start(activity, activityName, ActivityType.ExecuteUserCode);
|
|
}
|
|
|
|
returnValue = this.InvokeBeginDelegate(instance, inputs, callback, state);
|
|
callFailed = false;
|
|
}
|
|
}
|
|
catch (System.Security.SecurityException e)
|
|
{
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning);
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(AuthorizationBehavior.CreateAccessDeniedFaultException());
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
TraceUtility.TraceUserCodeException(e, this.beginMethod);
|
|
if (e is FaultException)
|
|
{
|
|
callFaulted = true;
|
|
callFailed = false;
|
|
}
|
|
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
ServiceModelActivity.Stop(activity);
|
|
|
|
// An exception during the InvokeBegin will not call InvokeEnd,
|
|
// so we complete the trace and performance counters here.
|
|
if (callFailed || callFaulted)
|
|
{
|
|
StopOperationInvokeTrace(callFailed, callFaulted, this.EndMethod.Name);
|
|
StopOperationInvokePerformanceCounters(callFailed, callFaulted, endMethod.Name.Substring(ServiceReflector.EndMethodNamePrefix.Length));
|
|
}
|
|
}
|
|
return returnValue;
|
|
}
|
|
|
|
internal static void GetActivityInfo(ref ServiceModelActivity activity, ref Activity boundOperation)
|
|
{
|
|
if (TraceUtility.MessageFlowTracingOnly)
|
|
{
|
|
if (null != OperationContext.Current)
|
|
{
|
|
Guid activityId = TraceUtility.GetReceivedActivityId(OperationContext.Current);
|
|
if (activityId != Guid.Empty)
|
|
{
|
|
DiagnosticTraceBase.ActivityId = activityId;
|
|
}
|
|
}
|
|
}
|
|
else if (DiagnosticUtility.ShouldUseActivity || TraceUtility.ShouldPropagateActivity)
|
|
{
|
|
object activityInfo = TraceUtility.ExtractAsyncOperationContextActivity();
|
|
if (activityInfo != null)
|
|
{
|
|
if (DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
activity = activityInfo as ServiceModelActivity;
|
|
boundOperation = ServiceModelActivity.BoundOperation(activity, true);
|
|
}
|
|
else if (TraceUtility.ShouldPropagateActivity)
|
|
{
|
|
if (activityInfo is Guid)
|
|
{
|
|
Guid activityId = (Guid)activityInfo;
|
|
boundOperation = Activity.CreateActivity(activityId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result)
|
|
{
|
|
object returnVal;
|
|
|
|
if (instance == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxNoServiceObject)));
|
|
|
|
outputs = EmptyArray.Allocate(this.OutputParameterCount);
|
|
bool callFailed = true;
|
|
bool callFaulted = false;
|
|
ServiceModelActivity activity = null;
|
|
|
|
try
|
|
{
|
|
Activity boundOperation = null;
|
|
GetActivityInfo(ref activity, ref boundOperation);
|
|
using (boundOperation)
|
|
{
|
|
returnVal = this.InvokeEndDelegate(instance, outputs, result);
|
|
callFailed = false;
|
|
}
|
|
}
|
|
catch (SecurityException e)
|
|
{
|
|
DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning);
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(AuthorizationBehavior.CreateAccessDeniedFaultException());
|
|
}
|
|
catch (FaultException)
|
|
{
|
|
callFaulted = true;
|
|
callFailed = false;
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
ServiceModelActivity.Stop(activity);
|
|
StopOperationInvokeTrace(callFailed, callFaulted, this.endMethod.Name);
|
|
StopOperationInvokePerformanceCounters(callFailed, callFaulted, this.endMethod.Name.Substring(ServiceReflector.EndMethodNamePrefix.Length));
|
|
}
|
|
|
|
return returnVal;
|
|
}
|
|
|
|
internal static void StartOperationInvokeTrace(string methodName)
|
|
{
|
|
if (TD.OperationInvokedIsEnabled())
|
|
{
|
|
OperationContext context = OperationContext.Current;
|
|
EventTraceActivity eventTraceActivity = null;
|
|
if (context != null && context.IncomingMessage != null)
|
|
{
|
|
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(context.IncomingMessage);
|
|
}
|
|
if (TD.OperationInvokedIsEnabled())
|
|
{
|
|
TD.OperationInvoked(eventTraceActivity, methodName, TraceUtility.GetCallerInfo(OperationContext.Current));
|
|
}
|
|
if (TD.OperationCompletedIsEnabled() || TD.OperationFaultedIsEnabled() || TD.OperationFailedIsEnabled())
|
|
{
|
|
TraceUtility.UpdateAsyncOperationContextWithStartTime(eventTraceActivity, DateTime.UtcNow.Ticks);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal static void StopOperationInvokeTrace(bool callFailed, bool callFaulted, string methodName)
|
|
{
|
|
if (!(TD.OperationCompletedIsEnabled() ||
|
|
TD.OperationFaultedIsEnabled() ||
|
|
TD.OperationFailedIsEnabled()))
|
|
{
|
|
return;
|
|
}
|
|
|
|
EventTraceActivity eventTraceActivity;
|
|
long startTime;
|
|
TraceUtility.ExtractAsyncOperationStartTime(out eventTraceActivity, out startTime);
|
|
long duration = TraceUtility.GetUtcBasedDurationForTrace(startTime);
|
|
|
|
if (callFailed)
|
|
{
|
|
if (TD.OperationFailedIsEnabled())
|
|
{
|
|
TD.OperationFailed(eventTraceActivity, methodName, duration);
|
|
}
|
|
}
|
|
else if (callFaulted)
|
|
{
|
|
if (TD.OperationFaultedIsEnabled())
|
|
{
|
|
TD.OperationFaulted(eventTraceActivity, methodName, duration);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (TD.OperationCompletedIsEnabled())
|
|
{
|
|
TD.OperationCompleted(eventTraceActivity, methodName, duration);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal static void StartOperationInvokePerformanceCounters(string methodName)
|
|
{
|
|
if (PerformanceCounters.PerformanceCountersEnabled)
|
|
{
|
|
PerformanceCounters.MethodCalled(methodName);
|
|
}
|
|
}
|
|
|
|
internal static void StopOperationInvokePerformanceCounters(bool callFailed, bool callFaulted, string methodName)
|
|
{
|
|
if (PerformanceCounters.PerformanceCountersEnabled)
|
|
{
|
|
if (callFailed)
|
|
{
|
|
PerformanceCounters.MethodReturnedError(methodName);
|
|
}
|
|
else if (callFaulted)
|
|
{
|
|
PerformanceCounters.MethodReturnedFault(methodName);
|
|
}
|
|
else
|
|
{
|
|
PerformanceCounters.MethodReturnedSuccess(methodName);
|
|
}
|
|
}
|
|
}
|
|
|
|
InvokeBeginDelegate InvokeBeginDelegate
|
|
{
|
|
get
|
|
{
|
|
EnsureIsInitialized();
|
|
return invokeBeginDelegate;
|
|
}
|
|
}
|
|
|
|
InvokeEndDelegate InvokeEndDelegate
|
|
{
|
|
get
|
|
{
|
|
EnsureIsInitialized();
|
|
return invokeEndDelegate;
|
|
}
|
|
}
|
|
|
|
int InputParameterCount
|
|
{
|
|
get
|
|
{
|
|
EnsureIsInitialized();
|
|
return this.inputParameterCount;
|
|
}
|
|
}
|
|
|
|
int OutputParameterCount
|
|
{
|
|
get
|
|
{
|
|
EnsureIsInitialized();
|
|
return this.outputParameterCount;
|
|
}
|
|
}
|
|
|
|
void EnsureIsInitialized()
|
|
{
|
|
if (this.invokeBeginDelegate == null)
|
|
{
|
|
// Only pass locals byref because InvokerUtil may store temporary results in the byref.
|
|
// If two threads both reference this.count, temporary results may interact.
|
|
int inputParameterCount;
|
|
InvokeBeginDelegate invokeBeginDelegate = new InvokerUtil().GenerateInvokeBeginDelegate(this.beginMethod, out inputParameterCount);
|
|
this.inputParameterCount = inputParameterCount;
|
|
|
|
int outputParameterCount;
|
|
InvokeEndDelegate invokeEndDelegate = new InvokerUtil().GenerateInvokeEndDelegate(this.endMethod, out outputParameterCount);
|
|
this.outputParameterCount = outputParameterCount;
|
|
this.invokeEndDelegate = invokeEndDelegate;
|
|
this.invokeBeginDelegate = invokeBeginDelegate; // must set this last due to ----
|
|
}
|
|
}
|
|
}
|
|
}
|