'Some services are not able to be constructed (Error while validating the service descriptor 'ServiceType

Hi @P. G. Choudhury, what you are creating now is a middleware but not an interface, but you are trying to add lifecycle for this middleware which should only be appliable for interface and the implementation.

Middleware is constructed once at application startup when the middleware pipeline is being built. This makes the middleware looks like singleton. But middleware is executed per request. Each request flows through the middleware pipeline, invoking the Invoke or InvokeAsync method of each middleware component in sequence and this makes the middleware looks like scoped.

If you want to use middleware to do custom exception dealation, you can use code below and in Program.cs, pls use this middleware by app.UseMiddleware<ExceptionMiddleware>(); .By the way, please use ILogger<ExceptionMiddleware> instead of ILogger.

public class ExceptionMiddleware
{
    private readonly RequestDelegate _next;
    //private readonly ILogger _logger;
    private readonly ILogger<ExceptionMiddleware> _logger;
    public ExceptionMiddleware(RequestDelegate next, ILogger<ExceptionMiddleware> logger)
    {
        _logger = logger;
        _next = next;
    }
    public async Task InvokeAsync(HttpContext httpContext)
    {
        try
        {
            await _next(httpContext);
        }
        catch (Exception exp)
        {
            _logger.LogError($"An unhandled exception has occurred:{exp.GetBaseException}");
            await HandleExceptionAsync(httpContext, exp);
        }
    }
    private async Task HandleExceptionAsync(HttpContext httpContext, Exception exp)
    {
        httpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
        httpContext.Response.ContentType = "application/json";
        await httpContext.Response.WriteAsync(new ErrorDetails
        {
            StatusCode = httpContext.Response.StatusCode,
            Message = "Internal Server Error from Custom Middleware"
        }.ToString());
    }
}

And I also find you create ConfigureExceptionHandler method in your codes, you might want to use IExceptionHandler to handle known exceptions. You can follow the Microsoft document to drive it.

If the answer is the right solution, please click "Accept Answer" and kindly upvote it. If you have extra questions about this answer, please click "Comment".

Note: Please follow the steps in our documentation to enable e-mail notifications if you want to receive the related email notification for this thread.

Best regards,

Tiny

Hello Choudhury,

You’re running into that annoying error because you’re registering your ExceptionMiddleware as a singleton with AddSingleton<ExceptionMiddleware>(). Middleware in ASP.NET Core isn’t meant to be registered like a regular service. When you do that, you can run into lifetime issues, especially if your middleware depends on things like loggers or database contexts that aren’t singletons themselves. That’s why you’re seeing the error at var app = builder.Build();.

Here is the solutions:

1. Don’t register your middleware as a singleton.

Just remove this line:

builder.Services.AddSingleton<ExceptionMiddleware>();

2. Let ASP.NET Core handle the middleware.

Add your middleware to the pipeline like this:

app.UseMiddleware<ExceptionMiddleware>();

Or, if you have an extension method:

app.ConfigureCustomExceptionMiddleware();

3. Use the right logger type in your middleware.

Change your constructor to use the generic logger:

   public class ExceptionMiddleware
   {
       private readonly RequestDelegate _next;
       private readonly ILogger<ExceptionMiddleware> _logger;
 
       public ExceptionMiddleware(RequestDelegate next, ILogger<ExceptionMiddleware> logger)
       {
           _logger = logger;
           _next = next;
       }
 
       public async Task InvokeAsync(HttpContext httpContext)
       {
           try
           {
               await _next(httpContext);
           }
           catch (Exception exp)
           {
               _logger.LogError($"An unhandled exception has occurred: {exp.GetBaseException()}");
               await HandleExceptionAsync(httpContext, exp);
           }
       }
 
       private async Task HandleExceptionAsync(HttpContext httpContext, Exception exp)
       {
           httpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
           httpContext.Response.ContentType = "application/json";
           await httpContext.Response.WriteAsync(new ErrorDetails
           {
               StatusCode = httpContext.Response.StatusCode,
               Message = "Internal Server Error from Custom Middleware"
           }.ToString());
       }
   }

That’s it! No need to mess with service lifetimes for middleware, just add it to the pipeline, and ASP.NET Core will take care of the rest. If you want to handle known exceptions in a more advanced way, you can look into using IExceptionHandler as well, but for most custom error handling, this middleware approach is perfect.

Hope that helps!

Hello Choudhury,

You’re running into that annoying error because you’re registering your ExceptionMiddleware as a singleton with AddSingleton<ExceptionMiddleware>(). Middleware in ASP.NET Core isn’t meant to be registered like a regular service. When you do that, you can run into lifetime issues, especially if your middleware depends on things like loggers or database contexts that aren’t singletons themselves. That’s why you’re seeing the error at var app = builder.Build();.

What should you do instead?:

1. Don’t register your middleware as a singleton.

Just remove this line:

builder.Services.AddSingleton<ExceptionMiddleware>();

2. Let ASP.NET Core handle the middleware.

Add your middleware to the pipeline like this:

app.UseMiddleware<ExceptionMiddleware>();

Or, if you have an extension method:

app.ConfigureCustomExceptionMiddleware();

3. Use the right logger type in your middleware.

Change your constructor to use the generic logger:

   public class ExceptionMiddleware
   {
       private readonly RequestDelegate _next;
       private readonly ILogger<ExceptionMiddleware> _logger;
 
       public ExceptionMiddleware(RequestDelegate next, ILogger<ExceptionMiddleware> logger)
       {
           _logger = logger;
           _next = next;
       }
 
       public async Task InvokeAsync(HttpContext httpContext)
       {
           try
           {
               await _next(httpContext);
           }
           catch (Exception exp)
           {
               _logger.LogError($"An unhandled exception has occurred: {exp.GetBaseException()}");
               await HandleExceptionAsync(httpContext, exp);
           }
       }
 
       private async Task HandleExceptionAsync(HttpContext httpContext, Exception exp)
       {
           httpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
           httpContext.Response.ContentType = "application/json";
           await httpContext.Response.WriteAsync(new ErrorDetails
           {
               StatusCode = httpContext.Response.StatusCode,
               Message = "Internal Server Error from Custom Middleware"
           }.ToString());
       }
   }

If you want to handle known exceptions in a more advanced way, you can look into using IExceptionHandler as well, but for most custom error handling, this middleware approach is perfect.

Hope that helps!

Hi,

The error you’re encountering is happening because you’re registering your ExceptionMiddleware as a singleton using AddSingleton<ExceptionMiddleware>(). In ASP.NET Core, middleware isn’t meant to be registered like a typical service. Doing so can cause issues with service lifetimes, especially if your middleware depends on services like loggers or database contexts that aren’t singletons. That’s why you’re seeing the error at var app = builder.Build().

Here’s how you can resolve this:

1. Remove the singleton registration for your middleware.

You can simply remove this line:

builder.Services.AddSingleton<ExceptionMiddleware>();

2. Let ASP.NET Core manage the middleware.

Add your middleware to the pipeline like this:

app.UseMiddleware<ExceptionMiddleware>();

Or, if you have an extension method:

app.ConfigureCustomExceptionMiddleware();

3. Update your middleware to use the correct logger type.

Change your constructor to use the generic logger:

   public class ExceptionMiddleware
   {
       private readonly RequestDelegate _next;
       private readonly ILogger<ExceptionMiddleware> _logger;
 
       public ExceptionMiddleware(RequestDelegate next, ILogger<ExceptionMiddleware> logger)
       {
           _logger = logger;
           _next = next;
       }
 
       public async Task InvokeAsync(HttpContext httpContext)
       {
           try
           {
               await _next(httpContext);
           }
           catch (Exception exp)
           {
               _logger.LogError($"An unhandled exception has occurred: {exp.GetBaseException()}");
               await HandleExceptionAsync(httpContext, exp);
           }
       }
 
       private async Task HandleExceptionAsync(HttpContext httpContext, Exception exp)
       {
           httpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
           httpContext.Response.ContentType = "application/json";
           await httpContext.Response.WriteAsync(new ErrorDetails
           {
               StatusCode = httpContext.Response.StatusCode,
               Message = "Internal Server Error from Custom Middleware"
           }.ToString());
       }
   }

If you’d like to handle specific exceptions in a more advanced way, you might also want to look into using IExceptionHandler. But for most custom error handling, this middleware approach should work well.

Hope this helps!