Lifetime Scope in Blazor Client and Server Apps

Short Summary

We basically know 3 types of lifetimes when it come to ASP.NET Core

• Singleton - One instance is created and is shared across all users
• Transient - Whenever someone is asking for a service always a new instance is created
• Scoped - One instance per request

Setup

Let's create three services, for each lifetime one:

public class MySingletonService
{
    public Guid ServiceId { get; set; } = Guid.NewGuid();
}

public class MyScopedService
{
    public Guid ServiceId { get; set; } = Guid.NewGuid();
}

public class MyTransientService
{
    public Guid ServiceId { get; set; } = Guid.NewGuid();
}

Now we need two pages. We reuse the template which comes shipped with Visual Studio. Therefore we adapt the Index.razor and Counter.razor in this way:

@page "/"
@inject MySingletonService singletonService
@inject MyScopedService scopedService
@inject MyTransientService transientService

<h1>Index</h1>
<ul>
    <li>Singleton Service - @singletonService.ServiceId</li>
    <li>Scoped Service - @scopedService.ServiceId</li>
    <li>Transient Service - @transientService.ServiceId</li>
</ul>

@page "/"
@inject MySingletonService singletonService
@inject MyScopedService scopedService
@inject MyTransientService transientService

<h1>Counter</h1>
<ul>
    <li>Singleton Service - @singletonService.ServiceId</li>
    <li>Scoped Service - @scopedService.ServiceId</li>
    <li>Transient Service - @transientService.ServiceId</li>
</ul>

They look the same only the header is different. Now we want to check a few scenarios:

• Start the app and land on our home page
• Navigate to the counter page from the navigation menu
• Reload the index page with F5
• Open the page in incognito mode

Blazor Client

Now we have a look how the ID's look on the client side

Now let's have a look. First the obvious one: Transient. I guess it is not weird that all of the services are unique. Now let's come to Singleton. Why is it different for Hard reload and incognito? The answer is easy: The code runs on your local machine and not on a server, therefore this is basically like a new program running which initializes the container once more. Now Scoped: Why do we have the same ID when we navigate to a different page? Well that is the idea behind a single page application. You don't make a new "request". You are still in the same request as you started. That also explains why a hard reload gives you a new ID, because now we have a new request.

Let's go to the server side

Blazor Server

The not surprising part first: We have the same picture for Transient in client as well as server. If we have a look at the Singleton we see a difference. The incognito mode does not lead to a new instance. And that makes sense, because actually the server is the same. Blazor server "just" opens a SignalR connection with the HTML content rendered by the server. The main book of work is done on the server. Last but not least Scoped. We see the exact same picture as with the client side blazor. Of course client and server share a lot of similarities and this is also true for the Scoped lifetime.

Conclusion

Blazor client and server have a slightly different lifetime scope than your "normal" ASP.NET Core Web API or MVC project.