protected async override ValueTask <object> InvokeCoreAsync(DomainService instance, object[] inputs, bool disableStackTraces)
{
ServiceInvokeResult invokeResult;
try
{
InvokeDescription invokeDescription = new InvokeDescription(this.operation, inputs);
invokeResult = await instance.InvokeAsync(invokeDescription, CancellationToken.None).ConfigureAwait(false);
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
throw ServiceUtility.CreateFaultException(ex, disableStackTraces);
}
if (invokeResult.HasValidationErrors)
{
throw ServiceUtility.CreateFaultException(invokeResult.ValidationErrors, disableStackTraces);
}
else
{
return(invokeResult.Result);
}
}
private DomainService GetDomainService(object instance, WcfDomainServiceContext context)
{
// create and initialize the DomainService for this request
DomainServiceBehavior.DomainServiceInstanceInfo instanceInfo =
(DomainServiceBehavior.DomainServiceInstanceInfo)instance;
try
{
DomainService domainService = DomainService.Factory.CreateDomainService(instanceInfo.DomainServiceType, context);
instanceInfo.DomainServiceInstance = domainService;
return(domainService);
}
catch (TargetInvocationException tie)
{
if (tie.InnerException != null)
{
throw ServiceUtility.CreateFaultException(tie.InnerException, context.DisableStackTraces);
}
throw ServiceUtility.CreateFaultException(tie, context.DisableStackTraces);
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
throw ServiceUtility.CreateFaultException(ex, context.DisableStackTraces);
}
}
private DomainService GetDomainService(object instance)
{
// create and initialize the DomainService for this request
DomainServiceBehavior.DomainServiceInstanceInfo instanceInfo =
(DomainServiceBehavior.DomainServiceInstanceInfo)instance;
IServiceProvider serviceProvider = (IServiceProvider)OperationContext.Current.Host;
DomainServiceContext context = new DomainServiceContext(serviceProvider, this.operationType);
try
{
DomainService domainService = DomainService.Factory.CreateDomainService(instanceInfo.DomainServiceType, context);
instanceInfo.DomainServiceInstance = domainService;
return(domainService);
}
catch (TargetInvocationException tie)
{
if (tie.InnerException != null)
{
throw ServiceUtility.CreateFaultException(tie.InnerException);
}
throw ServiceUtility.CreateFaultException(tie);
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
throw ServiceUtility.CreateFaultException(ex);
}
}
protected override object InvokeCore(object instance, object[] inputs, out object[] outputs)
{
outputs = ServiceUtility.EmptyObjectArray;
IEnumerable <ValidationResult> validationErrors;
object result;
try
{
InvokeDescription invokeDescription = new InvokeDescription(this.operation, inputs);
result = ((DomainService)instance).Invoke(invokeDescription, out validationErrors);
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
throw ServiceUtility.CreateFaultException(ex);
}
if (validationErrors != null && validationErrors.Any())
{
throw ServiceUtility.CreateFaultException(validationErrors);
}
return(result);
}
private async ValueTask <object> InvokeAsync(object instance, object[] inputs)
{
long startTicks = DiagnosticUtility.GetTicks();
bool disableStackTraces = true;
var operationContext = OperationContext.Current;
try
{
WcfDomainServiceContext context = new WcfDomainServiceContext((IServiceProvider)operationContext.Host, this.operationType);
disableStackTraces = context.DisableStackTraces;
DiagnosticUtility.OperationInvoked(this.Name, operationContext);
DomainService domainService = this.GetDomainService(instance, context);
// invoke the operation and process the result
this.ConvertInputs(inputs);
var result = await this.InvokeCoreAsync(domainService, inputs, disableStackTraces).ConfigureAwait(false);
result = this.ConvertReturnValue(result);
DiagnosticUtility.OperationCompleted(this.Name, DiagnosticUtility.GetDuration(startTicks), operationContext);
return(result);
}
catch (FaultException)
{
DiagnosticUtility.OperationFaulted(this.Name, DiagnosticUtility.GetDuration(startTicks), operationContext);
// if the exception has already been transformed to a fault
// just rethrow it
throw;
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
DiagnosticUtility.OperationFailed(this.Name, DiagnosticUtility.GetDuration(startTicks), operationContext);
// We need to ensure that any time an exception is thrown by the
// service it is transformed to a properly sanitized/configured
// fault exception.
throw ServiceUtility.CreateFaultException(ex, disableStackTraces);
}
}
protected override async ValueTask <object> InvokeCoreAsync(DomainService instance, object[] inputs, bool disableStackTraces)
{
IEnumerable <ChangeSetEntry> changeSetEntries = (IEnumerable <ChangeSetEntry>)inputs[0];
try
{
return(await ChangeSetProcessor.ProcessAsync(instance, changeSetEntries));
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
throw ServiceUtility.CreateFaultException(ex, disableStackTraces);
}
}
public object Invoke(object instance, object[] inputs, out object[] outputs)
{
string operationName = this.Name;
long startTicks = DateTime.UtcNow.Ticks;
object result = null;
DomainService domainService = null;
try
{
DiagnosticUtility.OperationInvoked(operationName);
domainService = this.GetDomainService(instance);
// invoke the operation and process the result
this.ConvertInputs(inputs);
result = this.InvokeCore(domainService, inputs, out outputs);
result = this.ConvertReturnValue(result);
DiagnosticUtility.OperationCompleted(operationName, DiagnosticUtility.GetDuration(startTicks));
}
catch (FaultException)
{
DiagnosticUtility.OperationFaulted(operationName, DiagnosticUtility.GetDuration(startTicks));
// if the exception has already been transformed to a fault
// just rethrow it
throw;
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
DiagnosticUtility.OperationFailed(operationName, DiagnosticUtility.GetDuration(startTicks));
// We need to ensure that any time an exception is thrown by the
// service it is transformed to a properly sanitized/configured
// fault exception.
throw ServiceUtility.CreateFaultException(ex);
}
return(result);
}
protected override object InvokeCore(object instance, object[] inputs, out object[] outputs)
{
outputs = ServiceUtility.EmptyObjectArray;
ServiceQuery serviceQuery = null;
QueryAttribute queryAttribute = (QueryAttribute)this.operation.OperationAttribute;
if (queryAttribute.IsComposable)
{
object value;
if (OperationContext.Current.IncomingMessageProperties.TryGetValue(ServiceQuery.QueryPropertyName, out value))
{
serviceQuery = (ServiceQuery)value;
}
}
IEnumerable <ValidationResult> validationErrors;
int totalCount;
QueryResult <TEntity> result;
try
{
QueryOperationInvoker.SetOutputCachingPolicy(this.operation);
result = QueryProcessor.Process <TEntity>((DomainService)instance, this.operation, inputs, serviceQuery, out validationErrors, out totalCount);
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
QueryOperationInvoker.ClearOutputCachingPolicy();
throw ServiceUtility.CreateFaultException(ex);
}
if (validationErrors != null && validationErrors.Any())
{
throw ServiceUtility.CreateFaultException(validationErrors);
}
return(result);
}
protected override object InvokeCore(object instance, object[] inputs, out object[] outputs)
{
DomainService domainService = (DomainService)instance;
IEnumerable <ChangeSetEntry> changeSetEntries = (IEnumerable <ChangeSetEntry>)inputs[0];
outputs = ServiceUtility.EmptyObjectArray;
try
{
return(ChangeSetProcessor.Process(domainService, changeSetEntries));
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
throw ServiceUtility.CreateFaultException(ex);
}
}
protected override async ValueTask <object> InvokeCoreAsync(DomainService instance, object[] inputs, bool disableStackTraces)
{
ServiceQuery serviceQuery = null;
QueryAttribute queryAttribute = (QueryAttribute)this.operation.OperationAttribute;
// httpContext is lost on await so need to save it for later ise
HttpContext httpContext = HttpContext.Current;
if (queryAttribute.IsComposable)
{
object value;
if (OperationContext.Current.IncomingMessageProperties.TryGetValue(ServiceQuery.QueryPropertyName, out value))
{
serviceQuery = (ServiceQuery)value;
}
}
QueryResult <TEntity> result;
try
{
QueryOperationInvoker.SetOutputCachingPolicy(httpContext, this.operation);
result = await QueryProcessor.ProcessAsync <TEntity>(instance, this.operation, inputs, serviceQuery);
}
catch (Exception ex)
{
if (ex.IsFatal())
{
throw;
}
QueryOperationInvoker.ClearOutputCachingPolicy(httpContext);
throw ServiceUtility.CreateFaultException(ex, disableStackTraces);
}
if (result.ValidationErrors != null && result.ValidationErrors.Any())
{
throw ServiceUtility.CreateFaultException(result.ValidationErrors, disableStackTraces);
}
return(result);
}
