public object InvokeEnd(object instance, out object[] outputs, IAsyncResult result)
{
object obj2;
if (instance == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxNoServiceObject")));
}
outputs = EmptyArray.Allocate(this.OutputParameterCount);
bool flag = true;
bool flag2 = false;
try
{
ServiceModelActivity activity = null;
Activity boundOperation = null;
this.GetActivityInfo(ref activity, ref boundOperation);
using (boundOperation)
{
obj2 = this.InvokeEndDelegate(instance, outputs, result);
flag = false;
}
ServiceModelActivity.Stop(activity);
}
catch (SecurityException exception)
{
DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(AuthorizationBehavior.CreateAccessDeniedFaultException());
}
catch (FaultException)
{
flag2 = true;
flag = false;
throw;
}
finally
{
if (flag)
{
if (TD.OperationFailedIsEnabled())
{
TD.OperationFailed(this.EndMethod.Name, TraceUtility.GetUtcBasedDurationForTrace(TraceUtility.ExtractAsyncOperationStartTime()));
}
}
else if (flag2)
{
if (TD.OperationFaultedIsEnabled())
{
TD.OperationFaulted(this.EndMethod.Name, TraceUtility.GetUtcBasedDurationForTrace(TraceUtility.ExtractAsyncOperationStartTime()));
}
}
else if (TD.OperationCompletedIsEnabled())
{
TD.OperationCompleted(this.EndMethod.Name, TraceUtility.GetUtcBasedDurationForTrace(TraceUtility.ExtractAsyncOperationStartTime()));
}
if (PerformanceCounters.PerformanceCountersEnabled)
{
if (flag)
{
PerformanceCounters.MethodReturnedError(this.endMethod.Name.Substring("End".Length));
}
else if (flag2)
{
PerformanceCounters.MethodReturnedFault(this.endMethod.Name.Substring("End".Length));
}
else
{
PerformanceCounters.MethodReturnedSuccess(this.endMethod.Name.Substring("End".Length));
}
}
}
return(obj2);
}
private IEnumerable <IServiceContractGenerationExtension> GetBeforeExtensionsBuiltInContractGenerators()
{
return(EmptyArray <IServiceContractGenerationExtension> .Allocate(0));
}
private IEnumerable <IOperationContractGenerationExtension> GetAfterExtensionsBuiltInOperationGenerators()
{
return(EmptyArray <IOperationContractGenerationExtension> .Allocate(0));
}
public ValueTask <(Task returnValue, object[] outputs)> InvokeAsyncCore(object instance, object[] inputs)
{
EnsureIsInitialized();
if (instance == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.SFxNoServiceObject));
}
if (inputs == null)
{
if (_inputParameterCount > 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxInputParametersToServiceNull, _inputParameterCount)));
}
}
else if (inputs.Length != _inputParameterCount)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxInputParametersToServiceInvalid, _inputParameterCount, inputs.Length)));
}
object[] outputs = EmptyArray <object> .Allocate(_outputParameterCount);
//AsyncMethodInvoker.StartOperationInvokePerformanceCounters(taskMethod.Name);
object returnValue;
//bool callFailed = true;
//bool callFaulted = false;
//ServiceModelActivity activity = null;
//Activity boundActivity = null;
try
{
//AsyncMethodInvoker.CreateActivityInfo(ref activity, ref boundActivity);
//AsyncMethodInvoker.StartOperationInvokeTrace(taskMethod.Name);
//if (DiagnosticUtility.ShouldUseActivity)
//{
// string activityName = SR.Format(SR.ActivityExecuteMethod, taskMethod.DeclaringType.FullName, taskMethod.Name);
// ServiceModelActivity.Start(activity, activityName, ActivityType.ExecuteUserCode);
//}
returnValue = _invokeDelegate(instance, inputs, outputs);
if (returnValue == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(Task));
}
var returnValueTask = returnValue as Task;
if (returnValueTask != null)
{
// Return ValueTask which comletes once the task has completed
if (returnValueTask.IsCompleted)
{
if (returnValueTask.IsFaulted)
{
return(new ValueTask <(Task returnValue, object[] outputs)>(Task.FromException <(Task returnValue, object[] outputs)>(ConvertExceptionForFaultedTask(returnValueTask))));
}
else
{
return(new ValueTask <(Task returnValue, object[] outputs)>((returnValueTask, outputs)));
}
}
else
{
Task <(Task returnValue, object[] outputs)> completionTask = returnValueTask.ContinueWith(antecedant =>
{
if (returnValueTask.IsFaulted)
{
throw ConvertExceptionForFaultedTask(antecedant);
}
else
{
return(returnValue: antecedant, outputs);
}
});
return(new ValueTask <(Task returnValue, object[] outputs)>(completionTask));
}
//await returnValueTask;
}
// returnValue is null
return(new ValueTask <(Task returnValue, object[] outputs)>((returnValueTask, outputs)));
}
finally
{
// TODO: When brining boundActivity back, make sure it executes in the correct order with relation to
// called task completing.
//if (boundActivity != null)
//{
// ((IDisposable)boundActivity).Dispose();
//}
//ServiceModelActivity.Stop(activity);
// Any exception above means InvokeEnd will not be called, so complete it here.
//if (callFailed || callFaulted)
//{
//AsyncMethodInvoker.StopOperationInvokeTrace(callFailed, callFaulted, TaskMethod.Name);
//AsyncMethodInvoker.StopOperationInvokePerformanceCounters(callFailed, callFaulted, TaskMethod.Name);
//}
}
}
public object[] AllocateInputs()
{
return(EmptyArray <object> .Allocate(1));
}
private async Task <Tuple <object, object[]> > InvokeAsync(object instance, object[] inputs)
{
EnsureIsInitialized();
if (instance == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.SFxNoServiceObject));
}
if (inputs == null)
{
if (inputParameterCount > 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxInputParametersToServiceNull, inputParameterCount)));
}
}
else if (inputs.Length != inputParameterCount)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxInputParametersToServiceInvalid, inputParameterCount, inputs.Length)));
}
object[] outputs = EmptyArray <object> .Allocate(outputParameterCount);
//AsyncMethodInvoker.StartOperationInvokePerformanceCounters(taskMethod.Name);
object returnValue;
bool callFailed = true;
bool callFaulted = false;
//ServiceModelActivity activity = null;
//Activity boundActivity = null;
try
{
//AsyncMethodInvoker.CreateActivityInfo(ref activity, ref boundActivity);
//AsyncMethodInvoker.StartOperationInvokeTrace(taskMethod.Name);
//if (DiagnosticUtility.ShouldUseActivity)
//{
// string activityName = SR.Format(SR.ActivityExecuteMethod, taskMethod.DeclaringType.FullName, taskMethod.Name);
// ServiceModelActivity.Start(activity, activityName, ActivityType.ExecuteUserCode);
//}
returnValue = invokeDelegate(instance, inputs, outputs);
if (returnValue == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("task");
}
var returnValueTask = returnValue as Task;
if (returnValueTask != null)
{
// Only return once the task has completed
await returnValueTask;
}
callFailed = false;
return(Tuple.Create(returnValue, outputs));
}
catch (SecurityException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(AuthorizationBehavior.CreateAccessDeniedFaultException());
}
catch (FaultException)
{
callFaulted = true;
throw;
}
catch (Exception e)
{
TraceUtility.TraceUserCodeException(e, taskMethod);
throw;
}
finally
{
//if (boundActivity != null)
//{
// ((IDisposable)boundActivity).Dispose();
//}
//ServiceModelActivity.Stop(activity);
// Any exception above means InvokeEnd will not be called, so complete it here.
if (callFailed || callFaulted)
{
//AsyncMethodInvoker.StopOperationInvokeTrace(callFailed, callFaulted, TaskMethod.Name);
//AsyncMethodInvoker.StopOperationInvokePerformanceCounters(callFailed, callFaulted, TaskMethod.Name);
}
}
}
public object Invoke(object instance, object[] inputs, out object[] outputs)
{
outputs = EmptyArray.Allocate(0);
return(new NullMessage());
}
private async Task <Tuple <object, object[]> > InvokeAsync(object instance, object[] inputs)
{
EnsureIsInitialized();
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)));
}
object[] outputs = EmptyArray.Allocate(this.outputParameterCount);
AsyncMethodInvoker.StartOperationInvokePerformanceCounters(this.taskMethod.Name);
object returnValue;
ServiceModelActivity activity = null;
Activity boundActivity = null;
try
{
AsyncMethodInvoker.CreateActivityInfo(ref activity, ref boundActivity);
AsyncMethodInvoker.StartOperationInvokeTrace(this.taskMethod.Name);
if (DiagnosticUtility.ShouldUseActivity)
{
string activityName = SR.GetString(SR.ActivityExecuteMethod, this.taskMethod.DeclaringType.FullName, this.taskMethod.Name);
ServiceModelActivity.Start(activity, activityName, ActivityType.ExecuteUserCode);
}
OperationContext.EnableAsyncFlow();
returnValue = this.invokeDelegate(instance, inputs, outputs);
if (returnValue == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("task");
}
var returnValueTask = returnValue as Task;
if (returnValueTask != null)
{
// Only return once the task has completed
await returnValueTask;
}
return(Tuple.Create(returnValue, outputs));
}
catch (SecurityException e)
{
DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(AuthorizationBehavior.CreateAccessDeniedFaultException());
}
catch (Exception e)
{
TraceUtility.TraceUserCodeException(e, this.taskMethod);
throw;
}
finally
{
OperationContext.DisableAsyncFlow();
if (boundActivity != null)
{
((IDisposable)boundActivity).Dispose();
}
ServiceModelActivity.Stop(activity);
}
}