feat: Exception handling is improved

Author: drwatson1

ProjectTemplates/AspNetCore.WebApi/ReferenceProject/ReferenceProject/Controllers/ProductsController.cs

@@ -1,14 +1,16 @@
-using System;
+using AutoMapper;
+using Microsoft.AspNetCore.Mvc;
+using ReferenceProject.Exceptions;
+using ReferenceProject.Repo;
+using System;
 using System.Collections.Generic;
 using System.Linq;
-using AutoMapper;
-using Microsoft.AspNetCore.Mvc;
 
 namespace ReferenceProject.Controllers
 {
     [Route("[controller]")]
     [ApiController]
-    public class ProductsController : ControllerBase
+    public class ProductsController: ControllerBase
     {
         Repo.IProductsRepo ProductsRepo { get; }
         IMapper Mapper { get; }
@@ -25,8 +27,15 @@ public ProductsController(Repo.IProductsRepo productsRepo, IMapper mapper)
             return ProductsRepo.Get().Select(Mapper.Map<Dto.Product>);
         }
 
-        [HttpGet("action")]
-        public void Action()
+        [HttpGet]
+        [Route("{id}")]
+        public Dto.Product GetById(int id)
+        {
+            return Mapper.Map<Dto.Product>(ProductsRepo.GetById(id));
+        }
+
+        [HttpGet("ThrowAnException")]
+        public void ThrowAnException()
         {
             throw new Exception("Example exception");
         }

ProjectTemplates/AspNetCore.WebApi/ReferenceProject/ReferenceProject/Exceptions/DuplicateKeyException.cs

@@ -1,12 +1,13 @@
 using System;
 using System.Runtime.Serialization;
 
-namespace ReferenceProject.Repo
+namespace ReferenceProject.Exceptions
 {
     [Serializable]
     internal class DuplicateKeyException : Exception
     {
         public DuplicateKeyException()
+            : this("Duplicate key")
         {
         }
 

ProjectTemplates/AspNetCore.WebApi/ReferenceProject/ReferenceProject/Middleware/ExceptionMiddleware.cs

@@ -5,17 +5,29 @@
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Serialization;
-using ReferenceProject.Repo;
+using Microsoft.AspNetCore.Hosting;
+using ReferenceProject.Exceptions;
 
 namespace ReferenceProject.Middleware
 {
+    /// <summary>
+    /// Middleware to handle unhandled exceptions. 
+    /// It separates exceptions based on their type and returns different status codes and answers based on it, instead of 500 Internal Server Error code in all cases
+    /// </summary>
+    /// <remarks>
+    /// There is another way to do this - an exception filter.
+    /// However, a middleware is a preferred way to achieve this according to the official documentation.
+    /// To learn more see https://docs.microsoft.com/en-us/aspnet/core/mvc/controllers/filters?view=aspnetcore-2.2#exception-filters
+    /// </remarks>
     public class ExceptionMiddleware
     {
         RequestDelegate Next { get; }
-        public ILogger Logger { get; }
+        ILogger Logger { get; }
+        IHostingEnvironment Environment { get; }
 
-        public ExceptionMiddleware(RequestDelegate next, ILogger<ExceptionMiddleware> logger)
+        public ExceptionMiddleware(RequestDelegate next, ILogger<ExceptionMiddleware> logger, IHostingEnvironment environment)
         {
+            Environment = environment ?? throw new ArgumentNullException(nameof(environment));
             Logger = logger ?? throw new ArgumentNullException(nameof(logger));
             Next = next ?? throw new ArgumentNullException(nameof(next));
         }
@@ -29,6 +41,8 @@ public async Task InvokeAsync(HttpContext context)
             }
             catch (Exception ex)
             {
+                // If context.Response.HasStarted == true, then we can't write to the response stream anymore. So we have to restore the body.
+                // If we were don't do that we get an exception.
                 context.Response.Body = body;
                 await HandleExceptionAsync(context, ex);
             }
@@ -41,6 +55,7 @@ async Task HandleExceptionAsync(HttpContext context, Exception ex)
             context.Response.ContentType = "application/json";
             context.Response.StatusCode = statusCode;
 
+            // We can decide what the status code should be
             if (ex is KeyNotFoundException)
             {
                 context.Response.StatusCode = StatusCodes.Status404NotFound;
@@ -52,23 +67,27 @@ async Task HandleExceptionAsync(HttpContext context, Exception ex)
 
             await context.Response.WriteAsync(
                 JsonConvert.SerializeObject(
-                    new ErrorResponse(ex), 
-                    new JsonSerializerSettings()
-                    {
-                        ContractResolver = new CamelCasePropertyNamesContractResolver()
-                    }));
+                    new ErrorResponse(ex, Environment.IsDevelopment())));
 
             if (context.Response.StatusCode == 500)
             {
                 Logger.LogError(ex, "Unhandled exception occurred");
             }
+            else
+            {
+                Logger.LogDebug(ex, "Unhandled exception occurred");
+            }
         }
 
         class ErrorResponse
         {
-            public ErrorResponse(Exception ex)
+            public ErrorResponse(Exception ex, bool includeFullExceptionInfo)
             {
                 Error = new ExceptionDescription(ex);
+                if(includeFullExceptionInfo)
+                {
+                    Error.Exception = ex;
+                }
             }
 
             public ExceptionDescription Error { get; set; }
@@ -82,7 +101,7 @@ public ExceptionDescription(Exception ex)
             }
 
             public string Message { get; set; }
+            public Exception Exception { get; set; }
         }
-
     }
 }

ProjectTemplates/AspNetCore.WebApi/ReferenceProject/ReferenceProject/Middleware/ExceptionMiddlewareExtensions.cs

@@ -0,0 +1,13 @@
+using Microsoft.AspNetCore.Builder;
+
+namespace ReferenceProject
+{
+    public static class ExceptionMiddlewareExtensions
+    {
+        public static IApplicationBuilder UseExceptionHandler(
+            this IApplicationBuilder builder)
+        {
+            return builder.UseMiddleware<Middleware.ExceptionMiddleware>();
+        }
+    }
+}

ProjectTemplates/AspNetCore.WebApi/ReferenceProject/ReferenceProject/ReferenceProject.csproj

@@ -4,6 +4,10 @@
     <TargetFramework>netcoreapp2.1</TargetFramework>
   </PropertyGroup>
 
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+  </PropertyGroup>
+
   <ItemGroup>
     <Folder Include="wwwroot\" />
   </ItemGroup>

ProjectTemplates/AspNetCore.WebApi/ReferenceProject/ReferenceProject/Repo/ProductsRepo.cs

@@ -1,4 +1,5 @@
 using AutoMapper;
+using ReferenceProject.Exceptions;
 using ReferenceProject.Model;
 using System;
 using System.Collections.Generic;

ProjectTemplates/AspNetCore.WebApi/ReferenceProject/ReferenceProject/Startup.cs

@@ -29,6 +29,21 @@ public Startup(IConfiguration configuration, IHostingEnvironment env)
             {
                 DotNetEnv.Env.Load();
             }
+
+            JsonConvert.DefaultSettings = () => 
+                new JsonSerializerSettings()
+                {
+                    ContractResolver = new CamelCasePropertyNamesContractResolver(),
+                    NullValueHandling = NullValueHandling.Ignore,
+                    DefaultValueHandling = DefaultValueHandling.Include,
+                    ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
+                    //Formatting = Formatting.Indented,
+#if DEBUG
+                    Formatting = Formatting.Indented
+#else
+                    Formatting = Formatting.None
+#endif
+            };
         }
 
         public IConfiguration Configuration { get; }
@@ -44,7 +59,8 @@ public void ConfigureServices(IServiceCollection services)
                 // Add useful interface for accessing the IUrlHelper outside a controller.
                 .AddScoped<IUrlHelper>(x => x
                     .GetRequiredService<IUrlHelperFactory>()
-                    .GetUrlHelper(x.GetRequiredService<IActionContextAccessor>().ActionContext)).AddMvc()
+                    .GetUrlHelper(x.GetRequiredService<IActionContextAccessor>().ActionContext))
+                .AddMvc()
                 .AddJsonOptions(options =>
                 {
                     options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
@@ -91,8 +107,10 @@ public void ConfigureContainerCommon(ContainerBuilder builder)
         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
         public void Configure(IApplicationBuilder app/*, IHostingEnvironment env*/)
         {
-            app.UseMiddleware<ExceptionMiddleware>()
-                .UseMiddleware<PreventResponseCachingMiddleware>();
+            // Use our exception handler middleware before any other handlers
+            app.UseExceptionHandler();
+
+            app.UseMiddleware<PreventResponseCachingMiddleware>();
 
             app.UseCors(builder => builder
                 .AllowAnyOrigin()