Can't able to read the httpcontext object in catch block in .NET core

Question

0.00/5 (No votes)

See more:

I have to perform global error handling for that I have created a custom middle ware
but with error handling I have to log entire request also so in catch block I am logging the request also but in catch block the request body parameter is always blank where as in try block I am able to get the request body object

What I have tried:

C#

public class HTTPStatuseCodeExceptionMiddleware
    {
        private readonly RequestDelegate _next;
        private readonly IErrorLogApplicationService _ErrorLogApplicationService;
        public HTTPStatuseCodeExceptionMiddleware(RequestDelegate next, IErrorLogApplicationService ErrorLogApplicationService)
        {
            _next = next ?? throw new ArgumentNullException(nameof(next));
            _ErrorLogApplicationService = ErrorLogApplicationService;
        }

        public async Task Invoke(HttpContext context)
        {
            try
            {
                string IPAddress = GetIPAddress();
                string Request = FormatRequest(context.Request).Result;
                await _next(context);
            }
            catch (HTTPStatusCodeException ex)
            {
                context.Response.Clear();
                context.Response.StatusCode = ex.StatusCode;
                context.Response.ContentType = ex.ContentType;

                await context.Response.WriteAsync(ex.Message);
               // ErrorLog(context, ex);
                return;
            }
            catch(Exception ex)
            {
                
                string Request = FormatRequest(context.Request).Result;
                // ErrorLog(context, ex);
            }

        }

//Format Request method

private async Task<string> FormatRequest(HttpRequest request)
        {
            var body = request.Body;

            //This line allows us to set the reader for the request back at the beginning of its stream.
            request.EnableRewind();

            //We now need to read the request stream.  First, we create a new byte[] with the same length as the request stream...
            var buffer = new byte[Convert.ToInt32(request.ContentLength)];

            //...Then we copy the entire request stream into the new buffer.
            await request.Body.ReadAsync(buffer, 0, buffer.Length);

            //We convert the byte[] into a string using UTF8 encoding...
            var bodyAsText = Encoding.UTF8.GetString(buffer);

            //..and finally, assign the read body back to the request body, which is allowed because of EnableRewind()
            request.Body = body;

            return $"{request.Scheme} {request.Host}{request.Path} {request.QueryString} {bodyAsText}";
        }

Posted 24-Oct-19 19:12pm

Member 12749751

Updated 25-Oct-19 0:08am

RickZeeland

v2

Add a Solution

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Andy Lanng · Answer 1 · 2019-10-25T00:08:00

Don't use middleware, use a request filter instead.

Middleware should be used to handle exceptions. It should have always consider the response to be complete. We have a similar middleware that logs all traffic in and out of the service. We have filters that handle exceptions and turn them into graceful responses after logging the issue.

C#

public class GeneralExceptionFilterAttribute : ExceptionFilterAttribute {

        public override void OnException(HttpActionExecutedContext context) {
            FilterHandlerProvider.Instance.Handle(this, context);
        }

    }

I won't go into to much detail about FilterHandlerProvider.Instance, because we use a DI factory to handle different exception types. In this specific case, the Instance is set as our GeneralExceptionFilterAttribute.

C#

public class GeneralExceptionFilterAttributeHandler : IHandlesFilterAttribute<GeneralExceptionFilterAttribute,
        HttpActionExecutedContext> {

        private readonly ILogger _logger;

        public GeneralExceptionFilterAttributeHandler(ILogger logger) {
            _logger = logger;
        }

        public void Handle(GeneralExceptionFilterAttribute filter, HttpActionExecutedContext context) {

            var extraInformation = new List<object>();
#if DEBUG
            //We want to handle all exceptions when they occur so we break the debugger here to take a look at an unhandled general exception and try to handle it
            Debugger.Break();
#endif
            if (context.Exception is HttpResponseException responseException) {
                context.Response = responseException.Response;
            }
            else if (context.Exception is InvalidAggregateOperationException invalidAggregateOperationException) {
                extraInformation.Add(invalidAggregateOperationException.AggregateId);
                if (invalidAggregateOperationException.InnerException != null) {
                    if (context.Exception.InnerException is ItemsNotAvailableException itemsNotAvailableException) {
                        extraInformation.Add(itemsNotAvailableException.Type);
                    }
                }
            }
            else {
                context.Response = new HttpResponseMessage(HttpStatusCode.InternalServerError);
            }

            _logger.LogException(context.Exception, extraInformation.ToArray());
        }

    }

Our ILogger is a DI instance so you may want to do that differently.

Most importantly, any exception coming from a controller is handled, logged and a graceful response is set.

Here's some more reading on filters:
Understanding Filters in MVC[^]

Hope that helps ^_^