Exception Handling In .NET Core

Exception handling is a hot topic that is practically required for all real developement applications.

 

When we are going to develop any application in dotnet core it provides a very good concept, that is, middleware makes exeception handling very easy.

 

If we add this line of code in the pipeline under the configure method in startup.cs class and run the application then simply we get the error status code:

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
   app.Run(context => { throw new Exception("error"); });
}

as shown in image below,

 

This kind of error is not sufficient for any developer. Developers want some user friendly and propery readable message type of error.

 

In this case dotnet core provides inbulit middleware to get some user-friendly error.

 

Let's see it with an example.

 

In this case we need to Install Microsoft.AspNetCore.Diagnostics Package.

 

There are two ways to install this nuget packege

1. Using Packge Manager
2. Using Visual studio search option.

I am using Using Visual Studio search option as attached image.

 

 

Then after that I add the following code:

public void Configure(IApplicationBuilder app, IHostingEnvironment env) {
    if (env.IsDevelopment() || env.IsStaging()) {
        app.UseDeveloperExceptionPage();
    }
    app.Run(context => {
        throw new Exception("error");
    });
}

After running this application I am able to see an errror as shown in the image below.

 

 

In this article I will try to explain various easy ways to handle exceptions:

1. Try Catch block
2. In Built middleware
3. Custom Middleware
4. Exception Filter

Try Catch Block

 

It is one of the easiest ways to handle errors in any controller action method:

 

Let's see it with an example

[Route("api/[controller]")]
[ApiController]
public class TestController: ControllerBase {
    // GET: api/Test
    [HttpGet]
    public IActionResult Get() {
        try {
            var empList = new List < string > ();
            empList = null;
            var countItem = empList.Count();
            return Ok(empList);
        } catch (Exception ex) {
            return StatusCode(HttpContext.Response.StatusCode, "Internal server error");
        }
    }
}

When you run this application you will get this error:

 

Internal server error

 

So this kind of exception is working as expected, but we cannot use this code in any other controller action method. 

 

As we know when we develop any application then the main concern is that we should utilize greater code re-usablity.

 

In-built middleware

 

As above we have seen in-built middleware in the  UseDeveloperExceptionPage that is used to show exceptions in detail.

 

UseExceptionHandler is also an in-built middleware that we can use to handle exceptions.

 

In this case we will create some of our custom classes as show below:

public class CustomError {
    public int StatusCode {
        get;
        set;
    }
    public string Message {
        get;
        set;
    }
    public override string ToString() {
        return JsonConvert.SerializeObject(this);
    }
}

We will use this class in newly created static class and its extension method.

public static class CustomExcepExceptionExtensions {
    public static void CustomExceptionHandler(this IApplicationBuilder app, ILogger < CustomExcepExceptionExtensions > logger) {
        app.UseExceptionHandler(appError => {
            appError.Run(async context => {
                context.Response.StatusCode = (int) HttpStatusCode.InternalServerError;
                context.Response.ContentType = "application/json";
                var contextFeature = context.Features.Get < IExceptionHandlerFeature > ();
                if (contextFeature != null) {
                    logger.LogError($ "Null exception logged: {contextFeature.Error}");
                    await context.Response.WriteAsync(new CustomError() {
                        StatusCode = context.Response.StatusCode,
                            Message = "Internal Server Error."
                    }.ToString());
                }
            });
        });
    }
}

In this class we have created an extension method for UseExceptionHandler which we need to register in configure method.

 

As shown below:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILogger logger) {
    if (env.IsDevelopment()) {
        app.UseDeveloperExceptionPage();
    }
    app.CustomExceptionHandler(logger);
}

Custom Middleware

 

It is one of the best ways to do exception handling.

 

So for that let's create custom middleware.

public class CustomExceptionMiddleware {
    private readonly RequestDelegate _next;
    private readonly ILogger < CustomExceptionMiddleware > _logger;
    public CustomExceptionMiddleware(RequestDelegate next, ILogger < CustomExceptionMiddleware > logger) {
        _logger = logger;
        _next = next;
    }
    public async Task InvokeAsync(HttpContext httpContext) {
        try {
            await _next(httpContext);
        } catch (Exception ex) {
            _logger.LogError($ "Exception occur: {ex}");
            await HandleExceptionAsync(httpContext, ex);
        }
    }
    private Task HandleExceptionAsync(HttpContext context, Exception exception) {
        context.Response.ContentType = "application/json";
        context.Response.StatusCode = (int) HttpStatusCode.InternalServerError;
        return context.Response.WriteAsync(new CustomError() {
            StatusCode = context.Response.StatusCode,
                Message = "custom middleware error."
        }.ToString());
    }
}

Register this custom middleware in configure method.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
    if (env.IsDevelopment()) {
        app.UseDeveloperExceptionPage();
    }
    app.ConfigureCustomExceptionMiddleware();
}

Now the code part is completed. Let's run our application and hit the URL as shown in the below image.

 

 

We are getting an error as expected.

 

If you have any issue, please download the attached code and run it.

 

I hope this will help you to handle exceptions in dotnet core.

 

Thank you for taking your valuable time to read the full article.