Use [DebuggerDisableUserUnhandledExceptions]

src/Components/Endpoints/src/RazorComponentEndpointInvoker.cs

@@ -3,6 +3,7 @@
 
 using System.Buffers;
 using System.Diagnostics;
+using System.Runtime.CompilerServices;
 using System.Text;
 using System.Text.Encodings.Web;
 using Microsoft.AspNetCore.Antiforgery;
@@ -33,6 +34,9 @@ public Task Render(HttpContext context)
         return _renderer.Dispatcher.InvokeAsync(() => RenderComponentCore(context));
     }
 
+    // We do not want the debugger to consider NavigationExceptions caught by this method as user unhandled.
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    [DebuggerDisableUserUnhandledExceptions]
     private async Task RenderComponentCore(HttpContext context)
     {
         context.Response.ContentType = RazorComponentResultExecutor.DefaultContentType;

src/Components/Endpoints/src/Rendering/EndpointHtmlRenderer.Prerendering.cs

@@ -1,7 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 using System.Text.Encodings.Web;
 using Microsoft.AspNetCore.Components.Rendering;
 using Microsoft.AspNetCore.Components.Web.HtmlRendering;
@@ -88,6 +90,9 @@ public ValueTask<IHtmlAsyncContent> PrerenderComponentAsync(
         ParameterView parameters)
         => PrerenderComponentAsync(httpContext, componentType, prerenderMode, parameters, waitForQuiescence: true);
 
+    // We do not want the debugger to consider NavigationExceptions caught by this method as user unhandled.
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    [DebuggerDisableUserUnhandledExceptions]
     public async ValueTask<IHtmlAsyncContent> PrerenderComponentAsync(
         HttpContext httpContext,
         [DynamicallyAccessedMembers(Component)] Type componentType,
@@ -129,6 +134,9 @@ public async ValueTask<IHtmlAsyncContent> PrerenderComponentAsync(
         }
     }
 
+    // We do not want the debugger to consider NavigationExceptions caught by this method as user unhandled.
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    [DebuggerDisableUserUnhandledExceptions]
     internal async ValueTask<PrerenderedComponentHtmlContent> RenderEndpointComponent(
         HttpContext httpContext,
         [DynamicallyAccessedMembers(Component)] Type rootComponentType,

src/Components/Endpoints/src/Rendering/EndpointHtmlRenderer.Streaming.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Text.Encodings.Web;
@@ -37,6 +39,9 @@ public void InitializeStreamingRenderingFraming(HttpContext httpContext, bool is
         }
     }
 
+    // We do not want the debugger to consider NavigationExceptions caught by this method as user unhandled.
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    [DebuggerDisableUserUnhandledExceptions]
     public async Task SendStreamingUpdatesAsync(HttpContext httpContext, Task untilTaskCompleted, TextWriter writer)
     {
         // Important: do not introduce any 'await' statements in this method above the point where we write
@@ -80,6 +85,10 @@ public async Task SendStreamingUpdatesAsync(HttpContext httpContext, Task untilT
             HandleExceptionAfterResponseStarted(_httpContext, writer, ex);
             await writer.FlushAsync(); // Important otherwise the client won't receive the error message, as we're about to fail the pipeline
             await _httpContext.Response.CompleteAsync();
+
+            // We need to inform the debugger that this exception should be considered user unhandled unlike the NavigationException.
+            // Review: Is this necessary if the method attributed with [DebuggerDisableUserUnhandledExceptions] rethrows like this does?
+            Debugger.BreakForUserUnhandledException(ex);
             throw;
         }
     }

src/Middleware/Diagnostics/src/DeveloperExceptionPage/DeveloperExceptionPageMiddlewareImpl.cs

@@ -5,6 +5,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Metrics;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Text;
 using System.Text.Json;
 using System.Text.Json.Serialization;
@@ -102,8 +103,14 @@ private static void SetExceptionHandlerFeatures(ErrorContext errorContext)
     /// </summary>
     /// <param name="context"></param>
     /// <returns></returns>
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    [DebuggerDisableUserUnhandledExceptions]
     public async Task Invoke(HttpContext context)
     {
+        // We want to avoid treating exceptions as user unhandled if an exception filter like the DatabaseDeveloperPageExceptionFilter
+        // handles the exception rather than letting it flow to the default DisplayException method. This is because we don't want to stop the
+        // debugger if the developer shouldn't be handling the exception and instead just needs to do something like click a link to run a
+        // database migration.
         try
         {
             await _next(context);
@@ -122,6 +129,11 @@ public async Task Invoke(HttpContext context)
                     context.Response.StatusCode = StatusCodes.Status499ClientClosedRequest;
                 }
 
+                // Generally speaking, we do not expect application code to handle things like IOExceptions during a request
+                // body read due to a client disconnect. But this kind of thing should be rare in development, and developers
+                // might be surprised if an IOException propagating through user code was not considered user unhandled.
+                // That said, if developers complain, we consider removing the following line.
+                Debugger.BreakForUserUnhandledException(ex);
                 return;
             }
 
@@ -131,6 +143,8 @@ public async Task Invoke(HttpContext context)
             {
                 _logger.ResponseStartedErrorPageMiddleware();
                 _metrics.RequestException(exceptionName, ExceptionResult.Skipped, handler: null);
+
+                Debugger.BreakForUserUnhandledException(ex);
                 throw;
             }
 
@@ -161,11 +175,17 @@ public async Task Invoke(HttpContext context)
             }
             catch (Exception ex2)
             {
+                // Inform the debugger that the exception filter itself threw an exception.
+                // REVIEW: Is it okay for the same method to potentially call Debugger.BreakForUserUnhandledException
+                // multiple times with different exceptions in the same invocation?
+                Debugger.BreakForUserUnhandledException(ex2);
+
                 // If there's a Exception while generating the error page, re-throw the original exception.
                 _logger.DisplayErrorPageException(ex2);
             }
 
             _metrics.RequestException(exceptionName, ExceptionResult.Unhandled, handler: null);
+            Debugger.BreakForUserUnhandledException(ex);
             throw;
         }
 
@@ -178,6 +198,9 @@ public async Task Invoke(HttpContext context)
     // Assumes the response headers have not been sent.  If they have, still attempt to write to the body.
     private Task DisplayException(ErrorContext errorContext)
     {
+        // We need to inform the debugger that this exception should be considered user unhandled since it wasn't handled by an exception filter.
+        Debugger.BreakForUserUnhandledException(errorContext.Exception);
+
         var httpContext = errorContext.HttpContext;
         var headers = httpContext.Request.GetTypedHeaders();
         var acceptHeader = headers.Accept;