private static void Handle(ExceptionHandlerContext context)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
ExceptionContext exceptionContext = context.ExceptionContext;
ExceptionDispatchInfo exceptionInfo = exceptionContext.ExceptionInfo;
if (exceptionInfo == null)
{
throw Error.Argument("context", Resources.TypePropertyMustNotBeNull, typeof(ExceptionContext).Name, "ExceptionInfo");
}
CommandHandlerRequest request = exceptionContext.Request;
if (request == null)
{
throw Error.Argument("context", Resources.TypePropertyMustNotBeNull, typeof(ExceptionContext).Name, "Request");
}
if (exceptionContext.CatchBlock == ExceptionCatchBlocks.ExceptionFilter)
{
// The exception filter stage propagates unhandled exceptions by default (when no filter handles the
// exception).
return;
}
context.Result = new ResponseMessageResult(request.CreateErrorResponse(exceptionInfo.SourceException));
}
public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
// For exceptions at the top of the call stack, Result will start out non-null (due to
// LastChanceExceptionHandler). This class does not force exceptions back to unhandled in such cases, so it
// will not not trigger the host-level exception processing.
context.Result = null;
return TaskHelpers.Completed();
}
/// <summary>Calls an exception handler and determines the response handling it, if any.</summary>
/// <param name="handler">The unhandled exception handler.</param>
/// <param name="context">The exception context.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <returns>
/// A task that, when completed, contains the response message to return when the exception is handled, or
/// <see langword="null"/> when the exception remains unhandled.
/// </returns>
public static Task<HandlerResponse> HandleAsync(this IExceptionHandler handler, ExceptionContext context, CancellationToken cancellationToken)
{
if (handler == null)
{
throw Error.ArgumentNull("handler");
}
if (context == null)
{
throw Error.ArgumentNull("context");
}
ExceptionHandlerContext handlerContext = new ExceptionHandlerContext(context);
return HandleAsyncCore(handler, handlerContext, cancellationToken);
}
/// <summary>Calls an exception handler and determines the response handling it, if any.</summary>
/// <param name="handler">The unhandled exception handler.</param>
/// <param name="context">The exception context.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <returns>
/// A task that, when completed, contains the response message to return when the exception is handled, or
/// <see langword="null"/> when the exception remains unhandled.
/// </returns>
public static Task <HandlerResponse> HandleAsync(this IExceptionHandler handler, ExceptionContext context, CancellationToken cancellationToken)
{
if (handler == null)
{
throw Error.ArgumentNull("handler");
}
if (context == null)
{
throw Error.ArgumentNull("context");
}
ExceptionHandlerContext handlerContext = new ExceptionHandlerContext(context);
return(HandleAsyncCore(handler, handlerContext, cancellationToken));
}
public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
{
if (context != null)
{
ExceptionContext exceptionContext = context.ExceptionContext;
ExceptionContextCatchBlock catchBlock = exceptionContext.CatchBlock;
if (catchBlock != null && catchBlock.IsTopLevel)
{
context.Result = CreateDefaultLastChanceResult(exceptionContext);
}
}
return this.innerHandler.HandleAsync(context, cancellationToken);
}
public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
{
if (context != null)
{
ExceptionContext exceptionContext = context.ExceptionContext;
ExceptionContextCatchBlock catchBlock = exceptionContext.CatchBlock;
if (catchBlock != null && catchBlock.IsTopLevel)
{
context.Result = CreateDefaultLastChanceResult(exceptionContext);
}
}
return(this.innerHandler.HandleAsync(context, cancellationToken));
}
/// <summary>Determines whether the exception should be handled.</summary>
/// <param name="context">The exception handler context.</param>
/// <returns>
/// <see langword="true"/> if the exception should be handled; otherwise, <see langword="false"/>.
/// </returns>
/// <remarks>The default decision is only to handle exceptions caught at top-level catch blocks.</remarks>
public virtual bool ShouldHandle(ExceptionHandlerContext context)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
ExceptionContext exceptionContext = context.ExceptionContext;
ExceptionContextCatchBlock catchBlock = exceptionContext.CatchBlock;
if (catchBlock == null)
{
throw Error.ArgumentNull("context", Resources.TypePropertyMustNotBeNull, typeof(ExceptionContext), "CatchBlock");
}
return(catchBlock.IsTopLevel);
}
/// <summary>Determines whether the exception should be handled.</summary>
/// <param name="context">The exception handler context.</param>
/// <returns>
/// <see langword="true"/> if the exception should be handled; otherwise, <see langword="false"/>.
/// </returns>
/// <remarks>The default decision is only to handle exceptions caught at top-level catch blocks.</remarks>
public virtual bool ShouldHandle(ExceptionHandlerContext context)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
ExceptionContext exceptionContext = context.ExceptionContext;
ExceptionContextCatchBlock catchBlock = exceptionContext.CatchBlock;
if (catchBlock == null)
{
throw Error.ArgumentNull("context", Resources.TypePropertyMustNotBeNull, typeof(ExceptionContext), "CatchBlock");
}
return catchBlock.IsTopLevel;
}
/// <inheritdoc />
Task IExceptionHandler.HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
ExceptionContext exceptionContext = context.ExceptionContext;
if (exceptionContext.ExceptionInfo == null)
{
throw Error.Argument("context", Resources.TypePropertyMustNotBeNull, typeof(ExceptionContext).Name, "ExceptionInfo");
}
if (!this.ShouldHandle(context))
{
return(TaskHelpers.Completed());
}
return(this.HandleAsync(context, cancellationToken));
}
/// <inheritdoc />
Task IExceptionHandler.HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
ExceptionContext exceptionContext = context.ExceptionContext;
if (exceptionContext.ExceptionInfo == null)
{
throw Error.Argument("context", Resources.TypePropertyMustNotBeNull, typeof(ExceptionContext).Name, "ExceptionInfo");
}
if (!this.ShouldHandle(context))
{
return TaskHelpers.Completed();
}
return this.HandleAsync(context, cancellationToken);
}
private static async Task<HandlerResponse> HandleAsyncCore(IExceptionHandler handler, ExceptionHandlerContext context, CancellationToken cancellationToken)
{
Contract.Assert(handler != null);
Contract.Assert(context != null);
await handler.HandleAsync(context, cancellationToken);
ICommandHandlerResult result = context.Result;
if (result == null)
{
return null;
}
HandlerResponse response = await result.ExecuteAsync(cancellationToken);
if (response == null)
{
throw Error.ArgumentNull(Resources.TypeMethodMustNotReturnNull, typeof(ICommandHandlerResult).Name, "ExecuteAsync");
}
return response;
}
public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
{
Handle(context);
return(TaskHelpers.Completed());
}
public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
{
Handle(context);
return TaskHelpers.Completed();
}
private static async Task <HandlerResponse> HandleAsyncCore(IExceptionHandler handler, ExceptionHandlerContext context, CancellationToken cancellationToken)
{
Contract.Assert(handler != null);
Contract.Assert(context != null);
await handler.HandleAsync(context, cancellationToken);
ICommandHandlerResult result = context.Result;
if (result == null)
{
return(null);
}
HandlerResponse response = await result.ExecuteAsync(cancellationToken);
if (response == null)
{
throw Error.ArgumentNull(Resources.TypeMethodMustNotReturnNull, typeof(ICommandHandlerResult).Name, "ExecuteAsync");
}
return(response);
}
/// <summary>When overridden in a derived class, handles the exception synchronously.</summary>
/// <param name="context">The exception handler context.</param>
public virtual void Handle(ExceptionHandlerContext context)
{
}
/// <summary>When overridden in a derived class, handles the exception synchronously.</summary>
/// <param name="context">The exception handler context.</param>
public virtual void Handle(ExceptionHandlerContext context)
{
}