ASP.NET Core應(yīng)用錯(cuò)誤處理之StatusCodePagesMiddleware中間件針對(duì)響應(yīng)碼呈現(xiàn)錯(cuò)誤頁(yè)面

 public class StatusCodePagesMiddleware
 {
 public StatusCodePagesMiddleware(RequestDelegate next, IOptions<StatusCodePagesOptions> options);
 public Task Invoke(HttpContext context);
 }

 public class StatusCodePagesOptions
 {
 public Func<StatusCodeContext, Task> HandleAsync { get; set; }
 }

 public class StatusCodeContext
 { 
 public HttpContext HttpContext { get; }
 public RequestDelegate Next { get; }
 public StatusCodePagesOptions Options { get; }
 
 public StatusCodeContext(HttpContext context, StatusCodePagesOptions options, RequestDelegate next);
 }

 public class StatusCodePagesMiddleware
 {
 private RequestDelegate _next;
 private StatusCodePagesOptions _options;
 
 public StatusCodePagesMiddleware(RequestDelegate next, 
 IOptions<StatusCodePagesOptions> options)
 {
 _next = next;
 _options = options.Value;
 }
 public async Task Invoke(HttpContext context)
 { 
 await _next(context);
 var response = context.Response;
 if ((response.StatusCode >= 400 && response.StatusCode <= 599) &&!response.ContentLength.HasValue && string.IsNullOrEmpty(response.ContentType))
 {
 await _options.HandleAsync(new StatusCodeContext(context, _options, _next));
 }
 }
 }

 public interface IStatusCodePagesFeature
 {
 bool Enabled { get; set; }
 }
 
 public class StatusCodePagesFeature : IStatusCodePagesFeature
 {
 public bool Enabled { get; set; } = true ;
 }

 public class StatusCodePagesMiddleware
 {
 …
 public async Task Invoke(HttpContext context)
 {
 StatusCodePagesFeature feature = new StatusCodePagesFeature();
 context.Features.Set<IStatusCodePagesFeature>(feature);
 
 await _next(context);
 var response = context.Response;
 if ((response.StatusCode >= 400 && response.StatusCode <= 599) && !response.ContentLength.HasValue &&string.IsNullOrEmpty(response.ContentType) &&
 feature.Enabled)
 {
 await _options.HandleAsync(new StatusCodeContext(context, _options, _next));
 }
 }
 }

 public class Program
 {
 public static void Main()
 {
 new WebHostBuilder()
 .UseKestrel()
 .Configure(app => app
 .UseStatusCodePages(async context => await context.HttpContext.Response.WriteAsync("Error occurred!"))
 .Run(Invoke))
 .Build()
 .Run();
 }
 
 private static Random _random = new Random();
 private static Task Invoke(HttpContext context)
 {
 context.Response.StatusCode = 401;
 
 if (_random.Next() % 2 == 0)
 {
 context.Features.Get<IStatusCodePagesFeature>().Enabled = false;
 }
 return Task.CompletedTask;
 }
 }

 HTTP/1.1 401 Unauthorized
 Date: Sun, 18 Dec 2016 01:59:37 GMT
 Server: Kestrel
 Content-Length: 15
 
 Error occurred!
 
 
 HTTP/1.1 401 Unauthorized
 Date: Sun, 18 Dec 2016 01:59:38 GMT
 Content-Length: 0
 Server: Kestrel

 public static class StatusCodePagesExtensions
 { 
 public static IApplicationBuilder UseStatusCodePages(this IApplicationBuilder app)
 { 
 return app.UseMiddleware<StatusCodePagesMiddleware>();
 }
 
 public static IApplicationBuilder UseStatusCodePages(this IApplicationBuilder app, StatusCodePagesOptions options)
 {
 return app.UseMiddleware<StatusCodePagesMiddleware>(Options.Create(options));
 } 
 
 public static IApplicationBuilder UseStatusCodePages(this IApplicationBuilder app, Func<StatusCodeContext, Task> handler)
 { 
 return app.UseStatusCodePages(new StatusCodePagesOptions
 {
 HandleAsync = handler
 });
 }
 }

 public static class StatusCodePagesExtensions
 { 
 public static IApplicationBuilder UseStatusCodePages(this IApplicationBuilder app, string contentType, string bodyFormat)
 {
 return app.UseStatusCodePages(context =>
 {
 var body = string.Format(CultureInfo.InvariantCulture, bodyFormat, context.HttpContext.Response.StatusCode);
 context.HttpContext.Response.ContentType = contentType;
 return context.HttpContext.Response.WriteAsync(body);
 });
 }
 }

 public static class StatusCodePagesExtensions
 { 
 public static IApplicationBuilder UseStatusCodePagesWithRedirects(this IApplicationBuilder app, string locationFormat)
 {
 if (locationFormat.StartsWith("~"))
 {
 locationFormat = locationFormat.Substring(1);
 return app.UseStatusCodePages(context =>
 {
 var location = string.Format(CultureInfo.InvariantCulture, locationFormat, context.HttpContext.Response.StatusCode);
 context.HttpContext.Response.Redirect(context.HttpContext.Request.PathBase + location);
 return Task.CompletedTask;
 });
 }
 else
 {
 return app.UseStatusCodePages(context =>
 {
 var location = string.Format(CultureInfo.InvariantCulture, locationFormat, context.HttpContext.Response.StatusCode);
 context.HttpContext.Response.Redirect(location);
 return Task.CompletedTask;
 });
 }
 }
 }

 public class Program
 {
 private static Random _random = new Random();
 public static void Main()
 {
 new WebHostBuilder()
 .UseKestrel()
 .ConfigureServices(svcs => svcs.AddRouting())
 .Configure(app => app
 .UseStatusCodePagesWithRedirects("~/error/{0}")
 .UseRouter(builder=>builder.MapRoute("error/{statuscode}", HandleError))
 .Run(context=>Task.Run(()=>context.Response.StatusCode = _random.Next(400,599))))
 .Build()
 .Run();
 }
 
 private async static Task HandleError(HttpContext context)
 {
 var statusCode = context.GetRouteData().Values["statuscode"];
 await context.Response.WriteAsync($"Error occurred ({statusCode})");
 }
 }

 public static class StatusCodePagesExtensions
 {
 public static IApplicationBuilder UseStatusCodePagesWithReExecute(this IApplicationBuilder app, string pathFormat, string queryFormat = null);
 }

 public class Program
 {
 private static Random _random = new Random();
 public static void Main()
 {
 new WebHostBuilder()
 .UseKestrel()
 .ConfigureServices(svcs => svcs.AddRouting())
 .Configure(app => app
 .UseStatusCodePagesWithReExecute("/error/{0}")
 .UseRouter(builder=>builder.MapRoute("error/{statuscode}", HandleError))
 .Run(context=>Task.Run(()=>context.Response.StatusCode = _random.Next(400,599))))
 .Build()
 .Run();
 }
 
 private async static Task HandleError(HttpContext context)
 {
 var statusCode = context.GetRouteData().Values["statuscode"];
 await context.Response.WriteAsync($"Error occurred ({statusCode})");
 }
 }

 public static class StatusCodePagesExtensions
 { 
 public static IApplicationBuilder UseStatusCodePagesWithReExecute(this IApplicationBuilder app,string pathFormat,string queryFormat = null)
 {
 return app.UseStatusCodePages(async context =>
 {
 var newPath = new PathString(string.Format(CultureInfo.InvariantCulture, pathFormat, context.HttpContext.Response.StatusCode));
 var formatedQueryString = queryFormat == null ? null :string.Format(CultureInfo.InvariantCulture, queryFormat, context.HttpContext.Response.StatusCode); 
 context.HttpContext.Request.Path = newPath;
 context.HttpContext.Request.QueryString = newQueryString;
 await context.Next(context.HttpContext);
 });
 }
 }

 public interface IStatusCodeReExecuteFeature
 {
 string OriginalPath { get; set; }
 string OriginalPathBase { get; set; }
 }
 
 public class StatusCodeReExecuteFeature : IStatusCodeReExecuteFeature
 {
 public string OriginalPath { get; set; }
 public string OriginalPathBase { get; set; }
 public string OriginalQueryString { get; set; }
 }

 public static class StatusCodePagesExtensions
 {
 public static IApplicationBuilder UseStatusCodePagesWithReExecute(this IApplicationBuilder app,string pathFormat,string queryFormat = null)
 { 
 return app.UseStatusCodePages(async context =>
 {
 var newPath = new PathString(string.Format(CultureInfo.InvariantCulture, pathFormat, context.HttpContext.Response.StatusCode));
 var formatedQueryString = queryFormat == null ? null :string.Format(CultureInfo.InvariantCulture, queryFormat, context.HttpContext.Response.StatusCode);
 var newQueryString = queryFormat == null ? QueryString.Empty : new QueryString(formatedQueryString);
 
 var originalPath = context.HttpContext.Request.Path;
 var originalQueryString = context.HttpContext.Request.QueryString;
 
 context.HttpContext.Features.Set<IStatusCodeReExecuteFeature>(new StatusCodeReExecuteFeature()
 {
 OriginalPathBase = context.HttpContext.Request.PathBase.Value,
 OriginalPath = originalPath.Value,
 OriginalQueryString = originalQueryString.HasValue ? originalQueryString.Value : null,
 });
 
 context.HttpContext.Request.Path = newPath;
 context.HttpContext.Request.QueryString = newQueryString;
 try
 {
 await context.Next(context.HttpContext);
 }
 finally
 {
 context.HttpContext.Request.QueryString = originalQueryString;
 context.HttpContext.Request.Path = originalPath;
 context.HttpContext.Features.Set<IStatusCodeReExecuteFeature>(null);
 }
 });
 }
 }