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);
       }
     });
   }
 }