What does scoped lifetime for a service mean in Blazor (server)?

This is for Blazor (server).

According to this documentation, session scope for a service in Blazor (server side) means:

> Scoped services aren't reconstructed when navigating among components
> on the client, where the communication to the server takes place over
> the SignalR connection of the user's circuit, not via HTTP requests.

And in this blog article (seems to be knowledgable):

> It creates a scope for each so-called “circuit”. A circuit is created
> when a new browser tab connects to the Blazor server via the
> underlying SignalR transport, and it is terminated when the browser
> tab is closed again (or if the connection is lost and fails to
> reconnect within a specified time frame).

But in this Microsoft Q&A it says:

> If this is a Blazor Server question then scoped behaves like a
> singleton. The official documentation covers how service life time
> works..

I think a singleton is the same object across all circuits/sessions. The documentation is as follows.

> DI creates a single instance of the service. All components requiring
> a Singleton service receive the same instance of the service.

Of course "all components" can mean all components in a single circuit/session. Or it can mean all components across all circuits/sessions. I can see how if the "all components" is per circuit/session, then scoped is the same as singleton for most (all) use cases. But if singleton is a single instance across ever circuit/session, then they differ - a lot.

So what exactly is going on for scoped & singleton services on Blazor server?

Summary

The discussion on this got emotional (which I hate to see) and there is a lot of valuable discussion of this question in the two answers below. So no disrespect to them but I am going to summarize the answer here.

A singleton will return the same instance on every call. Good example of a use here, getting the sales tax rate for a location (like Boulder, Colorado). That information is the same for every user.

A scoped will return a different instance for each SignalR circuit (often referred to as scope in Blazor server). For the life of a circuit it will keep returning the same instance to that circuit/session. Good example here is a shopping cart.

What can lead to some confusion - both a singleton and scoped service will return the same instance for the life of the circuit. In that way they are identical.

But if there are two circuits to your server, the singleton will return the same instance to both while the scoped service will return a different instance to each. In this way they are very different.

Putting all 3 doc cites together, you should read:

• Any session connects to a Blazor server via SignalR
• When the session starts a new scope for that session is created

From now on we can treat session and scope as the same, because each session has its own scope that will survive until the session ends.

• Within a scope (which in this context is equal to session) there is no difference between services with a scoped or singleton lifetime, as we will get for both the same instance from the ServiceProvider again and again.

That what is meant be scoped behaves like a singleton, and you should also consider the first part If this is a Blazor Server question then. Seems most Blazor Server questions has to be treated in the context of a session, and because each session has its own scoped, which never changes ...

That is different to normal ASP.NET Server, where you get a new scope for each request.

I guess the most problems came up with DbContext as that is as scoped service and in ASP.NET you have a clean fresh context on every request. But with Blazor Server you can now have side effects because it is not fresh and clean anymore and maybe dirty from an older use within the current session.

What's going on is that they differ a lot.

Scoped services persist so long as a user keeps their circuit, i.e. they are connected. They are unique to that connection (basically, that browser tab while it is open).

Singleton services persist forever, and are shared by everyone. This allows you, for example, to send a message to all connected users, or to allow chat between multiple users in a group.

A typical usage for a game server would be to have a Singleton service to handle game rooms and game instances, and a Scoped service for each user which subscribes to it.

It's a little confusing when learning Blazor, because when you're alone on a dev machine, your experience of both will be exactly the same unless you open your site on multiple tabs / browsers.