Blazor rendering after computation or call

Blazor renders in multiple passes, and what you're experiencing is absolutely normal. My understanding is that this is so most of your page will load even if it's waiting for async data to get filled in (complex database search etc.)

There are two ways I've used to avoid throwing a null reference on async init:

1. Check for null. Don't worry, your component will initialize everything and render properly on the second pass.

@if (Exceptions is not null){
    foreach (var exception in Exceptions)
        {
            <tr>exception.Message</tr>
        }
}

2. Initialize your List in the declaration. This empty List will be available on the first pass:

@code{
    public List<TestEventModel> Exceptions { get; set; } = new List<TestEventModel>();
}

Where you see ...await task... in the picture a Render action can/will execute.

If you want to confirm this experimentally you can use this:

@foreach (var item in Items)  
{

}

public List<string> Items { get; set; } = new();

protected override async Task OnInitializedAsync()
{
    Console.WriteLine("OnInitializedAsync start");
    await Task.Delay(100);
    Console.WriteLine("OnInitializedAsync done");
    Items = new List<string> { "aa", "bb", "cc", };        
}

protected override Task OnAfterRenderAsync(bool firstRender)
{
    Console.WriteLine($"OnAfterRenderAsync {firstRender}");
    return base.OnAfterRenderAsync(firstRender);
}

This will print "OnInitializedAsync done" after the first rendering. Note that this is before Items is assigned.

When you remove the = new(); part you get your original NRE error again. When you then remove the Task.Delay() as well it will run w/o an error. That follows the non async path you first assumed: "according to the lifecycle it should start rendering only after the execution of OnInitialized".

It is all about the await, it has nothing to do with server prerendering.

As your looking for Why?

You call:

protected override async void OnInitialized()
{
        var exceptionsResponse = (await http.GetAsync("TestController")).Content.ReadAsStringAsync();
}

OnInitialized is the synchronous version of OnInitializedAsync - and should only run synchronous code. You've turned it into a fire-and-forget async void event handler.

It runs synchronously until it hits some real yielding code - http.GetAsync. At which point it yields back to the component SetParametersAsync. This runs to completion. By the time Exceptions =.. gets run SetParametersAsync has completed, the component has completed rendering and errored because Exceptions is still null.

You need to run your code in OnInitializedAsync(). This returns a task to SetParametersAsync which it can wait on, and only continues when OnInitializedAsync completes by returning a completed Task.

    protected override async Task OnInitializedAsync()
    {
        var exceptionsResponse = (await http.GetAsync("TestController")).Content.ReadAsStringAsync();
        Exceptions = JsonConvert.DeserializeObject<List<TestEventModel>>(await exceptionsResponse);
    }

You still need to check if Exceptions is null in the display code and display a Loading message because the initial component render may occur before OnInitializedAsync completes. A second render event which occurs once SetParametersAsync has completed will render the component correctly.

Something like:

<table class="table">
    <thead>
        <tr>Message</tr>
    </thead>
    <tbody>
@if (Exceptions != null)
{
        @foreach (var exception in Exceptions)
        {
            <tr><td>exception.Message</td></tr>
        }
}
else 
{
            <tr><td>Loading....</td></tr>
}
    </tbody>
</table>

When you call StateHasChanged in your code you need to ask why? There are valid reasons, but often it's to recover from a earlier coding mistake.