I'm getting the An Unhandled Exception error message for the umpteenth time

The yellow bar with “An unhandled exception occurred” is Blazor’s built‑in UI that appears whenever an exception escapes your component code or the Blazor framework on your circuit. It isn’t a special “environment” or “machine” error: it is a symptom that some code path in your app is throwing and not handling an exception.

Key points from the platform behavior:

1. What that yellow bar means

• Blazor renders a div with id="blazor-error-ui" when an unhandled exception occurs.
• In development, it tells the developer to look in the browser console for details.
• In production, it just shows a generic message and suggests reloading.
• The UI is part of the Blazor project template and is normally hidden via CSS until an error occurs.

2. Why it can affect one user and not another Blazor treats most unhandled exceptions as fatal to the circuit (the per‑browser‑tab connection and state on the server):

• Each browser tab/user has its own circuit.
• An unhandled exception kills only that circuit; other users/tabs continue normally.
• If only one account or machine sees the yellow bar, that user is hitting a code path (data, navigation, parameters, permissions, etc.) that throws, while others are not.

3. Where to look for the actual cause Unhandled exceptions can occur in several places:

• Component instantiation (constructors or injected services).
• Lifecycle methods (OnInitialized[Async], OnParametersSet[Async], etc.).
• Rendering logic (e.g., dereferencing null in markup like @someObject.Property).
• Event handlers (@onclick, @onchange, @bind, etc.).
• Component disposal (IDisposable.Dispose).
• JavaScript interop calls (IJSRuntime.InvokeAsync).
• Prerendering (exceptions during initial render on the server).

Any unhandled exception in those areas is logged and, for server‑side circuits, is fatal to that circuit.

4. How to actually diagnose it on the problem machine Since the yellow bar is only a generic indicator, the next steps are:

• Check the browser console on the affected machine
  • In development, Blazor sends full exception details to the browser console. The yellow bar explicitly tells to look there.
  • Compare what appears in the console on the failing machine vs. the working one.
• Check server logs
  • Blazor logs unhandled exceptions to ILogger providers configured in the app.
  • Use a persistent logging provider or APM (for example, Azure Application Insights) so that exceptions from specific users/machines can be inspected.

5. Make the app resilient so the yellow bar appears less often To prevent unhandled exceptions from killing circuits:

• Guard rendering logic against null
  • Example pattern:

        @if (person.Address != null)
        {
            <div>@person.Address.Line1</div>
            <div>@person.Address.Line2</div>
            <div>@person.Address.City</div>
            <div>@person.Address.Country</div>
        }
    

• Add try-catch with logging around risky operations
  • In lifecycle methods (e.g., data loading in OnParametersSetAsync).
  • In event handlers (e.g., database calls, HTTP calls, JS interop).
  • In Dispose if disposal logic can fail.
• Use environment‑appropriate error messages
  • For Blazor Web Apps, inject IHostEnvironment into MainLayout and show different text in production vs. development, while still logging full details.

6. Environment and detailed errors

• For server‑side rendering, RazorComponentsServiceOptions.DetailedErrors controls whether detailed error information is produced.
• It should only be enabled in the Development environment, typically:

    builder.Services.AddRazorComponents(options => 
        options.DetailedErrors = builder.Environment.IsDevelopment());
  

7. Why rebooting sometimes “fixes” it Rebooting or restarting the browser creates a new circuit and clears transient state, so if the exception was tied to a particular corrupted state or sequence of actions, it may not reoccur immediately. However, the underlying bug remains and will reappear when the same code path is hit again.

To move forward on the specific machine/account:

• Reproduce the issue and capture the browser console output and corresponding server logs.
• Identify which of the known exception locations (lifecycle, rendering, event handler, JS interop, etc.) is throwing.
• Add appropriate try-catch, null checks, and logging so that the app handles the error gracefully instead of letting it bubble up and terminate the circuit.

References:

• Handle errors in ASP.NET Core Blazor apps