Developer Exception Page Middleware in ASP.NET Core

In this article, I am going to discuss how to handle an unhandled exception using Developer Exception Page Middleware in ASP.NET Core application. Please read our previous article where we discussed how to serve static files using Static Files Middleware in ASP.NET Core Web Application. The exception handling is one of the key features of any application. We can handle the exception in many different ways. But in this article, we are going to discuss how we can use the Developer Exception Page Middleware to handle the unhandled exception. As part of this article, we are going to discuss the following concepts.

1. What is Developer Exception Page Middleware?
2. How to use Developer Exception Page Middleware in ASP.NET Core Application?
3. How to Customize the UseDeveloperExceptionPage Middleware in ASP.NET Core?
4. Where do we need to configure the UseDeveloperExceptionPage Middleware?

Understanding Developer Exception Page Middleware:
By default, the ASP.NET Core application simply returns a status code for an exception that is not handled by the application. Let us understand this with an example. Please modify the Configure() method of the startup class as shown below where we throw an exception.

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    app.Run(async (context) =>
    {
        throw new Exception("Error Occurred while processing your request");
        await context.Response.WriteAsync("Request handled and response generated");
    });
}

When you run the application you will get the following output.

As you can see in the above image it gives you the status code as 500 which means Internal Server Error. But as a developer when you are developing the application, you should have to know the detailed information about the exception on the page so that you can take necessary actions to fix the error.

How to use DeveloperExceptionPage Middleware in ASP.NET Core Application?
If you want your application to display a page that shows the detailed information about the unhandled exception, then you need to use the Developer Exception Page middleware. Let us modify the Configure() method as shown below to add the Developer Exception Page middleware which will handle the unhandled exception that occurred in our application.

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    app.Run(async (context) =>
    {
        throw new Exception("Error Occurred while processing your request");
        await context.Response.WriteAsync("Request handled and response generated");
    });
}

With the above change, now run the application and it will display the following page with the detailed information about the unhandled exception.

As you can see in the above image, the Developer Exception Page contains four tabs such as Stack, Queue, Cookies, and Headers. The Stack tab gives the information of stack trace which indicated where exactly the exception occurred, the file name and the line number that causes the exception. Query tab gives information about the query strings. The Cookies tab displays the information about the cookies set by the request and the Header tab gives the information about the headers which is sent by the client when makes the request.

Now if you verify the Query tab and Cookies tab, then you will not see any information as you are not passing any query string value in URL or you are not setting the cookies in the request. In our upcoming articles, we will discuss the Query string and Cookies in detail.

Note: Please Enable the Developer Exception Page Middleware only when the application is running in the Development environment. You don’t want to share detailed exception information when the application is running in the production environment.

How to Customize the UseDeveloperExceptionPage Middleware in ASP.NET Core?
If you want then you can also customize the UseDeveloperExceptionPage middleware. The point that you need to remember is whenever you want to customize a middleware component in ASP.NET Core then you need to use the respective Options object. For example

1. UseDeveloperExceptionPage => to customize this middleware use DeveloperExceptionPageOptions object
2. UseDefaultFiles => to customize this middleware use DefaultFilesOptions object
3. UseStaticFiles => to customize this middleware use StaticFileOptions object
4. UseFileServer => to customize this middleware use FileServerOptions object

As we are going to customize the UseDeveloperExceptionPage() middleware component, so we need to use the DeveloperExceptionPageOptions object as shown below.

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        DeveloperExceptionPageOptions developerExceptionPageOptions = new DeveloperExceptionPageOptions
        {
            SourceCodeLineCount = 5
        };
        app.UseDeveloperExceptionPage();
    }
    app.Run(async (context) =>
    {
        throw new Exception("Error Occurred while processing your request");
        await context.Response.WriteAsync("Request handled and response generated");
    });
}

The SourceCodeLineCount property of the DeveloperExceptionPageOptions class specifies the number of lines of code to include before and after the line of code that caused the exception.

Where do we need to configure the UseDeveloperExceptionPage Middleware?
We need to configure the UseDeveloperExceptionPage() Middleware as early as possible in the application’s request processing pipeline so that it can handle the unhandled exception and then display the Developer Exception Page with the detailed information about the exception.

Let us see what happened when we configure the UseDeveloperExceptionPage() middleware after the middleware using is Registered using the Run() method. Please modify the Configure() method as shown below.

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    app.Run(async (context) =>
    {
        throw new Exception("Error Occurred while processing your request");
        await context.Response.WriteAsync("Request handled and response generated");
    });
    if (env.IsDevelopment())
    {
        DeveloperExceptionPageOptions developerExceptionPageOptions = new DeveloperExceptionPageOptions
        {
            SourceCodeLineCount = 5
        };
        app.UseDeveloperExceptionPage();
    }
}

With the above changes when we run the application, it will not display the developer’s exception page instead of simply returns the default error status code. This is the reason why we need to configure the UseDeveloperExceptionPage() middleware as early as possible to handle the unhandled exception of the application in the request processing pipeline.

From the next article onwards, I am going to discuss ASP.NET Core MVC Application. In this article, I try to explain how to handle an unhandled exception using Developer Exception Page Middleware in ASP.NET Core application. I hope this article will help you to understand the Developer Exception Page Middleware.

Summary:
I hope this post will be helpful to understand the concept of Developer Exception Page Middleware in ASP.NET Core
Please share this post with your friends and colleagues.
For any queries please post a comment below.
Happy Coding 😉