public virtual Task <HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
{
if (_initialized)
{
// if user has registered a controller factory which produces the same controller instance, we should throw here
throw Error.InvalidOperation(SRResources.CannotSupportSingletonInstance, typeof(ApiController).Name, typeof(IHttpControllerActivator).Name);
}
Initialize(controllerContext);
// We can't be reused, and we know we're disposable, so make sure we go away when
// the request has been completed.
if (Request != null)
{
Request.RegisterForDispose(this);
}
HttpControllerDescriptor controllerDescriptor = controllerContext.ControllerDescriptor;
ServicesContainer controllerServices = controllerDescriptor.Configuration.Services;
HttpActionDescriptor actionDescriptor = controllerServices.GetActionSelector().SelectAction(controllerContext);
ActionContext.ActionDescriptor = actionDescriptor;
if (Request != null)
{
Request.SetActionDescriptor(actionDescriptor);
}
FilterGrouping filterGrouping = actionDescriptor.GetFilterGrouping();
IActionFilter[] actionFilters = filterGrouping.ActionFilters;
IAuthenticationFilter[] authenticationFilters = filterGrouping.AuthenticationFilters;
IAuthorizationFilter[] authorizationFilters = filterGrouping.AuthorizationFilters;
IExceptionFilter[] exceptionFilters = filterGrouping.ExceptionFilters;
IHttpActionResult result = new ActionFilterResult(actionDescriptor.ActionBinding, ActionContext,
controllerServices, actionFilters);
if (authorizationFilters.Length > 0)
{
result = new AuthorizationFilterResult(ActionContext, authorizationFilters, result);
}
if (authenticationFilters.Length > 0)
{
result = new AuthenticationFilterResult(ActionContext, this, authenticationFilters, result);
}
if (exceptionFilters.Length > 0)
{
IExceptionLogger exceptionLogger = ExceptionServices.GetLogger(controllerServices);
IExceptionHandler exceptionHandler = ExceptionServices.GetHandler(controllerServices);
result = new ExceptionFilterResult(ActionContext, exceptionFilters, exceptionLogger, exceptionHandler,
result);
}
return(result.ExecuteAsync(cancellationToken));
}
/// <summary>
/// Execute the request via the worker.
/// </summary>
/// <param name="request">The <see cref="HandlerRequest"/> to execute.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> to cancel the execution.</param>
/// <returns>The result of the command, if any.</returns>
public Task <HandlerResponse> ExecuteAsync(CommandHandlerRequest request, CancellationToken cancellationToken)
{
if (request == null)
{
throw Error.ArgumentNull("request");
}
cancellationToken.ThrowIfCancellationRequested();
ServicesContainer servicesContainer = request.Configuration.Services;
ICommandHandlerSelector handlerSelector = servicesContainer.GetHandlerSelector();
CommandHandlerDescriptor descriptor = handlerSelector.SelectHandler(request);
ICommandHandler commandHandler = descriptor.CreateHandler(request);
if (commandHandler == null)
{
throw CreateHandlerNotFoundException(descriptor);
}
request.RegisterForDispose(commandHandler, true);
CommandHandlerContext context = new CommandHandlerContext(request, descriptor);
context.Handler = commandHandler;
commandHandler.CommandContext = context;
CommandFilterGrouping commandFilterGrouping = descriptor.GetFilterGrouping();
ICommandHandlerResult result = new CommandHandlerFilterResult(context, servicesContainer, commandFilterGrouping.CommandHandlerFilters);
if (descriptor.RetryPolicy != RetryPolicy.NoRetry)
{
result = new RetryHandlerResult(descriptor.RetryPolicy, result);
}
if (commandFilterGrouping.ExceptionFilters.Length > 0)
{
IExceptionLogger exceptionLogger = ExceptionServices.GetLogger(servicesContainer);
IExceptionHandler exceptionHandler = ExceptionServices.GetHandler(servicesContainer);
result = new ExceptionFilterResult(context, commandFilterGrouping.ExceptionFilters, exceptionLogger, exceptionHandler, result);
}
return(result.ExecuteAsync(cancellationToken));
}
