اوه! خطایی که توانست به صورت مخفیانه وارد تولید شود، چه کار کنیم؟

public class ContactController : RenderController
{
    public ContactController(
        ILogger<RenderController> logger,
        ICompositeViewEngine compositeViewEngine,
        IUmbracoContextAccessor umbracoContextAccessor)
        : base(logger, compositeViewEngine, umbracoContextAccessor)
    {
    }

    public override IActionResult Index()
    {
        throw new Exception("Whoops, something went wrong!");
    }
}

public class Startup
{
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // ... other middlewares

        // 👇 Insert this middleware before the Umbraco middlewares.
        // The path that you enter here can be anything you want, but it cannot be a path with a file extension.
        app.UseExceptionHandler("/error");

        app.UseUmbraco()
            .WithMiddleware(u =>
            {
                // ... The rest of the pipeline
            }
    }
}

public class ServerErrorContentFinder : IContentFinder
{
    private readonly IHttpContextAccessor _httpContextAccessor;
    private readonly IUmbracoContextAccessor _umbracoContextAccessor;

    public ServerErrorContentFinder(IHttpContextAccessor httpContextAccessor, IUmbracoContextAccessor umbracoContextAccessor)
    {
        _httpContextAccessor = httpContextAccessor;
        _umbracoContextAccessor = umbracoContextAccessor;
    }

    public Task<bool> TryFindContent(IPublishedRequestBuilder request)
    {
        // 👇 Upon re-entry, the exception middleware adds a feature to the context with the details about the exception.
        // This let's us detect if we're handling errors currently or not.
        if (_httpContextAccessor.GetRequiredHttpContext().Features.Get<IExceptionHandlerPathFeature>() is null)
        {
            return Task.FromResult(false);
        }

        // at this point, we know that we are routing an error page
        var rootNode = GetRootNode(request);

        // 👇 In our example, the server error page is always below the homepage and of type ServerError,
        //    but you can use any logic you want to find the error page.
        var errorPage = rootNode.FirstChild<ServerError>();

        request.SetPublishedContent(errorPage);
        return Task.FromResult(true);
    }

    private IPublishedContent GetRootNode(IPublishedRequestBuilder request)
    {
        // 👇 Umbraco provides us with the appropriate root node automatically, so we can use that to select the root node.
        var umbracoContext = _umbracoContextAccessor.GetRequiredUmbracoContext();
        if (request.HasDomain())
        {
            return umbracoContext.Content!.GetById(request.Domain!.ContentId)!;
        }

        // 👇 if no domain is assigned, we have to fall back to the first node in the content root
        return umbracoContext.Content!.GetAtRoot().First();
    }
}

public class ServerErrorComposer : IComposer
{
    public void Compose(IUmbracoBuilder builder)
    {
        // 👇 Insert the content finder at the start so it has a chance to route the request before other content finders do.
        builder.ContentFinders().Insert<ServerErrorContentFinder>(0);
    }
}

public class ServerErrorCleanupMiddleware
{
    private readonly RequestDelegate _next;

    public ServerErrorCleanupMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // 👇 Only run this middleware if we're handling errors
        var errorRoutingFeature = context.Features.Get<IExceptionHandlerPathFeature>();
        if (errorRoutingFeature is null)
        {
            await _next(context);
            return;
        }

        // 👇 Delete the Umbraco route values so that umbraco will recalculate them
        context.Features.Set<UmbracoRouteValues>(null);

        // 👇 If the error path is set to a static file,
        //    we don't want to apply any further cleanup and should skip the rest of this middleware.
        if (context.Request.IsClientSideRequest())
        {
            await _next(context);
            return;
        }

        // 👇 The error feature contains the original request path.
        //    Umbraco will automatically calculate the umbraco domain for us if we reset the path
        var originalPath = context.Request.Path;
        context.Request.Path = errorRoutingFeature.Path;

        try
        {
            await _next(context);
        }
        finally
        {
            // 👇 after running the middleware, make sure to restore the path to the error path.
            // Otherwise the exception middleware gets stuck in a loop
            context.Request.Path = originalPath;
        }
    }
}

public class Startup
{
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // ... other middlewares

        app.UseExceptionHandler("/error");
        app.UseMiddleware<ServerErrorCleanupMiddleware>();

        app.UseUmbraco()
            .WithMiddleware(u =>
            {
                // ... The rest of the pipeline
            }
    }
}

public class ServerErrorController : RenderController
{
    public ServerErrorController(
        ILogger<RenderController> logger,
        ICompositeViewEngine compositeViewEngine,
        IUmbracoContextAccessor umbracoContextAccessor)
        : base(logger, compositeViewEngine, umbracoContextAccessor)
    {
    }

    public override IActionResult Index()
    {
        throw new Exception("Oof, the error page doesn't work!");
    }
}

public class Startup
{
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // ... other middlewares

        // 👇 Add another exception handler here that points to a static file
        app.UseExceptionHandler("/error.html");
        app.UseExceptionHandler("/error");
        app.UseMiddleware<ServerErrorCleanupMiddleware>();

        app.UseUmbraco()
            .WithMiddleware(u =>
            {
                // ... The rest of the pipeline
            }
    }
}

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <title>500 Server Error</title>
</head>
<body>
    <h1>Oops! This page doesn't seem to work right now</h1>
</body>
</html>

public class ServerErrorResponseCodeMiddleware
{
    private readonly RequestDelegate _next;

    public ServerErrorResponseCodeMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public Task InvokeAsync(HttpContext context)
    {
        // 👇 As soon as we start writing the response to the client,
        // we need to check if we're sending an error response.
        // If we do: ensure that the statuscode is 500
        context.Response.OnStarting(() =>
        {
            var exceptionPathFeature = context.Features.Get<IExceptionHandlerPathFeature>();

            if (exceptionPathFeature is not null)
            {
                context.Response.StatusCode = StatusCodes.Status500InternalServerError;
            }

            return Task.CompletedTask;
        });

        return _next(context);
    }
}

public class Startup
{
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // ... other middlewares

        // 👇 Add the middleware right before all other error middlewares
        app.UseMiddleware<ServerErrorResponseCodeMiddleware>();
        app.UseExceptionHandler("/error.html");
        app.UseExceptionHandler("/error");
        app.UseMiddleware<ServerErrorCleanupMiddleware>();

        app.UseUmbraco()
            .WithMiddleware(u =>
            {
                // ... The rest of the pipeline
            }
    }
}