internal async Task ProcessRequestAsync(HttpContextBase context)
{
Exception exception = _exceptionInfo.SourceException;
Contract.Assert(exception != null);
CancellationToken cancellationToken = CancellationToken.None;
HttpResponseException responseException = exception as HttpResponseException;
if (responseException != null)
{
// This method call is hardend and designed not to throw exceptions (since they won't be caught and
// handled further by its callers).
await HttpControllerHandler.CopyResponseAsync(context, context.GetOrCreateHttpRequestMessage(),
responseException.Response, cancellationToken);
}
else
{
// This method call is hardend and designed not to throw exceptions (since they won't be caught and
// handled further by its callers).
bool handled = await HttpControllerHandler.CopyErrorResponseAsync(
WebHostExceptionCatchBlocks.HttpWebRoute, context, context.GetOrCreateHttpRequestMessage(),
null, _exceptionInfo.SourceException, cancellationToken, _exceptionLogger, _exceptionHandler);
if (!handled)
{
_exceptionInfo.Throw();
}
}
}
public override RouteData GetRouteData(HttpContextBase httpContext)
{
try
{
if (HttpRoute is HostedHttpRoute)
{
return(base.GetRouteData(httpContext));
}
else
{
// if user passed us a custom IHttpRoute, then we should invoke their function instead of the base
HttpRequestMessage request = httpContext.GetOrCreateHttpRequestMessage();
IHttpRouteData data = HttpRoute.GetRouteData(httpContext.Request.ApplicationPath, request);
return(data == null ? null : data.ToRouteData());
}
}
catch (HttpResponseException e)
{
// Task.Wait is fine here as ConvertResponse calls into MediaTypeFormatter.WriteToStreamAsync which happens
// synchronously in the default case (our default formatters are synchronous).
HttpControllerHandler.ConvertResponse(httpContext, e.Response, httpContext.GetOrCreateHttpRequestMessage()).Wait();
httpContext.Response.End();
return(null);
}
}
public void Index()
{
GlobalConfiguration.Configuration.Routes.MapHttpRoute("wheather", "wheather/{areaCode}/{days}");
HttpRequest request = new HttpRequest("wheather.aspx", "http://www.artech.com/wheather/010/2", null);
HttpResponse response = new HttpResponse(new StringWriter());
HttpContext context = new HttpContext(request, response);
RouteData routeData = RouteTable.Routes.GetRouteData(new HttpContextWrapper(context));
HttpControllerHandler httpHandler = new HttpControllerHandler(routeData, new HttpRouteDataTraceHandler());
httpHandler.ProcessRequestAsync(context).Wait();
}
internal async Task ProcessRequestAsync(HttpContextBase context)
{
Exception exception = _exceptionInfo.SourceException;
Contract.Assert(exception != null);
HttpRequestMessage request = context.GetOrCreateHttpRequestMessage();
HttpResponseMessage response = null;
CancellationToken cancellationToken = context.Response.GetClientDisconnectedTokenWhenFixed();
HttpResponseException responseException = exception as HttpResponseException;
try
{
if (responseException != null)
{
response = responseException.Response;
Contract.Assert(response != null);
// This method call is hardened and designed not to throw exceptions (since they won't be caught
// and handled further by its callers).
await HttpControllerHandler.CopyResponseAsync(context, request, response, _exceptionLogger,
_exceptionHandler, cancellationToken);
}
else
{
// This method call is hardened and designed not to throw exceptions (since they won't be caught and
// handled further by its callers).
bool handled = await HttpControllerHandler.CopyErrorResponseAsync(
WebHostExceptionCatchBlocks.HttpWebRoute, context, request, null,
_exceptionInfo.SourceException, _exceptionLogger, _exceptionHandler, cancellationToken);
if (!handled)
{
_exceptionInfo.Throw();
}
}
}
finally
{
// The other HttpTaskAsyncHandler is HttpControllerHandler; it has similar cleanup logic.
request.DisposeRequestResources();
request.Dispose();
if (response != null)
{
response.Dispose();
}
}
}
public static HttpRequestMessage GetOrCreateHttpRequestMessage(this HttpContextBase context)
{
if (context == null)
{
throw Error.ArgumentNull("context");
}
HttpRequestMessage request = context.GetHttpRequestMessage();
if (request == null)
{
request = HttpControllerHandler.ConvertRequest(context);
context.SetHttpRequestMessage(request);
}
return(request);
}
protected override bool ProcessConstraint(HttpContextBase httpContext, object constraint, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
{
IHttpRouteConstraint httpRouteConstraint = constraint as IHttpRouteConstraint;
if (httpRouteConstraint != null)
{
HttpRequestMessage request = httpContext.GetHttpRequestMessage();
if (request == null)
{
request = HttpControllerHandler.ConvertRequest(httpContext);
httpContext.SetHttpRequestMessage(request);
}
return(httpRouteConstraint.Match(request, HttpRoute, parameterName, values, ConvertRouteDirection(routeDirection)));
}
return(base.ProcessConstraint(httpContext, constraint, parameterName, values, routeDirection));
}
internal async Task ProcessRequestAsync(HttpContextBase context)
{
Exception exception = _exceptionInfo.SourceException;
Contract.Assert(exception != null);
OperationCanceledException canceledException = exception as OperationCanceledException;
if (canceledException != null)
{
// If the route throws a cancelation exception, then we'll abort the request instead of
// reporting an 'error'. We don't expect this to happen, but aborting the request is
// consistent with our behavior in other hosts.
context.Request.Abort();
return;
}
HttpRequestMessage request = context.GetOrCreateHttpRequestMessage();
HttpResponseMessage response = null;
CancellationToken cancellationToken =
context.Response.GetClientDisconnectedTokenWhenFixed();
HttpResponseException responseException = exception as HttpResponseException;
try
{
if (responseException != null)
{
response = responseException.Response;
Contract.Assert(response != null);
// This method call is hardened and designed not to throw exceptions (since they won't be caught
// and handled further by its callers).
await HttpControllerHandler.CopyResponseAsync(
context,
request,
response,
_exceptionLogger,
_exceptionHandler,
cancellationToken
);
}
else
{
// This method call is hardened and designed not to throw exceptions (since they won't be caught and
// handled further by its callers).
bool handled = await HttpControllerHandler.CopyErrorResponseAsync(
WebHostExceptionCatchBlocks.HttpWebRoute,
context,
request,
null,
_exceptionInfo.SourceException,
_exceptionLogger,
_exceptionHandler,
cancellationToken
);
if (!handled)
{
_exceptionInfo.Throw();
}
}
}
catch (OperationCanceledException)
{
// This block handles cancellations that might occur while we're writing an 'error' response.
//
// HttpTaskAsyncHandler treats a canceled task as an unhandled exception (logged to Application event
// log). Instead of returning a canceled task, abort the request and return a completed task.
context.Request.Abort();
}
finally
{
// The other HttpTaskAsyncHandler is HttpControllerHandler; it has similar cleanup logic.
request.DisposeRequestResources();
request.Dispose();
if (response != null)
{
response.Dispose();
}
}
}
