Unexpected identical object obtained for each http request for scoped service

Question

I have two endpoints:

/x that is defined in Endpoint.Register() (Bipin Joshi's approach to organize endpoints)
/y that is defined in Main() (the default of minimal api template)

As I expect that instances of Endpoint and Foo are different for each http request, I register them as scoped.

Unfortunately, Foo object instantiated in /x are always identical for all http requests. It is not what I expect. Foo objects instantiated in /y are different as expected.

Question

What causes this issue?

public class Foo{}

public class Endpoint
{
    private readonly ILogger<Endpoint> logger;
    private readonly Foo foo;

    public Endpoint(ILogger<Endpoint> logger, Foo foo)
    {
        this.logger = logger;
        this.foo = foo;
    }

    public void Register(WebApplication app)
    {
        app.MapGet("/x", () =>
        {
            // it unexpectedly produces the same foo!
            logger.Log(LogLevel.Warning, $"x: {foo.GetHashCode()}");
            return Results.Ok();
        });
    }
}



public  class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);

     
        builder.Services.AddEndpointsApiExplorer();
        builder.Services.AddSwaggerGen();
        builder.Services.AddScoped<Foo>();
        builder.Services.AddScoped<Endpoint>();

        var app = builder.Build();


        if (app.Environment.IsDevelopment())
        {
            app.UseSwagger();
            app.UseSwaggerUI();
        }

        app.UseHttpsRedirection();


        using (var scope = app.Services.CreateScope())
        {
            scope.ServiceProvider.GetService<Endpoint>()?.Register(app);
        }



        app.MapGet("/y", (ILogger<Endpoint> logger, Foo foo) =>
        {
            // it expectedly produces a different foo for each request.
            logger.Log(LogLevel.Warning, $"y: {foo.GetHashCode()}");
            return Results.Ok();
        });
  

        app.Run();
    }
}

Is Bipin Joshi's the sixth approach (see my link above, in which the services are injected in a wrapping class and shared among endpoints) recommended to organize endpoints? — The Real Masochist, Sep 02 '22 at 15:33
@DanielA.White: I changed the implementation of `Foo` with random id and the problem still exists. So reusing hashcode must not be the culprit. :-) — The Real Masochist, Sep 02 '22 at 16:19
Probably because the scoped services invoked in `Main` are promoted as singleton? — The Real Masochist, Sep 02 '22 at 16:33

Guru Stron · Accepted Answer · 2022-09-03T05:18:08.250

// it unexpectedly produces the same foo!

Actually this is pretty much expected. The following code:

using (var scope = app.Services.CreateScope())
{
   scope.ServiceProvider.GetService<Endpoint>()?.Register(app);
}

Creates a scope which creates an instance of Foo which will be captured by lambda (via lambda closure mechanism) and will be reused for the whole app lifetime (as is observed by you). I.e. the following quote:

Unfortunately, Foo object instantiated in /x are always identical for all http requests

is not actually true, there is no Foo object instantiated in /x handler, it reuses the same instance (note that by default for classes GetHashCode is computed based on an object's reference).

I would argue that this registration method is overengineered, cumbersome, confusing and in some cases outright faulty (as the one in the article which will lead to problems with the reused/shared context) and I would recommend against using it.

Unexpected identical object obtained for each http request for scoped service

Question

1 Answers1