C# Two GraphServiceClient singleton instances

In my application (.NET Web API), I need to call Microsoft Graph API using two different credentials set (completely different tenant).
When I was using only one, the case was simple - I just did a setup in DI part of Program.cs:

var clientSecretCredential = new ClientSecretCredential(b2cSettings.TenantId, b2cSettings.ClientId, b2cSettings.ClientSecret, tokenCredentialOptions);

// Use a single client instance for the lifetime of the application
services.AddSingleton(sp =>
{
    return new GraphServiceClient(clientSecretCredential, new[] { "https://graph.microsoft.com/.default" });
});

which allowed me to just inject it to whichever service I needed, like so:

    public GraphApiClient(
        GraphServiceClient graphServiceClient)
    {
        _graphServiceClient = graphServiceClient;
    }

Obviously, there is no way to re-use that for second set of credentials - it will just pick the last registered GraphServiceClient instance.

It smells like some common pattern, but it does not seem to be a good candidate for factory (I want only TWO instances across app lifetime - each with different credentials). I also wonder how would service "client" (class using it) specify which GraphServiceClient to retrieve in runtime.

I imagine some "aggregate" class with methods like:

RegisterGraphApiClientWithCredentials(string tenantId, string clientId, string clientSecret); // <- this would be done once, in Program.cs

RetrieveGraphApiClientWithCredentials(string tenantId, string clientId, string clientSecret); // <- this would be done whenever some service would need actual client instance

How should I approach this problem? Microsoft advise single instance for the lifetime of the application. Will this approach collide with that?

Thank You in advance!

In my use case I was reading/writing data from/to two tenants.

I've registered as a singleton a class that holds GraphServiceClient instances accessed by tenant id

public class GraphServiceClientProvider : IDisposable
{
    private bool disposedValue;

    private readonly IDictionary<string, GraphServiceClient> _clients;

    public GraphServiceClient this[string tenantId] => _clients[tenantId];

    public GraphServiceClientProvider(IDictionary<string, GraphServiceClient> clients)
    {
        _clients = clients;
    }       

    protected virtual void Dispose(bool disposing)
    {
        if (!disposedValue)
        {
            if (disposing)
            {
                foreach (var client in _clients.Values)
                {
                    client.Dispose();
                }
            }
            disposedValue = true;
        }
    }

    public void Dispose()
    {
        Dispose(disposing: true);
        GC.SuppressFinalize(this);
    }
}

in Program.cs

var tokenCredentialOptions = new ClientSecretCredentialOptions();
builder.Services.AddSingleton(x =>
{
    var scopes = new[] { "https://graph.microsoft.com/.default" };
    var dict = new Dictionary<string, GraphServiceClient>
    {
        { "tenantId1", new GraphServiceClient(new ClientSecretCredential("tenantId1", "clientId1", "clientSecret1", tokenCredentialOptions), scopes) },
        { "tenantId2", new GraphServiceClient(new ClientSecretCredential("tenantId2", "clientId2", "clientSecret2", tokenCredentialOptions), scopes) }
    };
    return new GraphServiceClientProvider(dict);
});
builder.Services.AddSingleton<IUsersService, UsersService>();

Example of usage

public class UserService : IUserService
{
    private readonly GraphServiceClientProvider _clientProvider;

    public UserService(GraphServiceClientProvider clientProvider)
    {
        _clientProvider = clientProvider;
    }

    public List<User> GetUsers(string tenantId)
    {
        var client = _clientProvider[tenantId];
        ...
    }
}

set one interface with multiple implements?

builder.Services.AddTransient<ClientFlowService>();
builder.Services.AddTransient<ClientFlowService2>();
builder.Services.AddTransient<ClientServiceResolver>(serviceProvider => client =>
{
    return client switch
    {
        "client1" => serviceProvider.GetService<ClientFlowService>(),
        "client2" => serviceProvider.GetService<ClientFlowService2>(),
        _ => throw new NotImplementedException()
    };
});

IClientFlowService.cs :

using Microsoft.Graph;

namespace WebMvcException.Services
{
    public delegate IClientService ClientServiceResolver(string client);

    public interface IClientService
    {
        public GraphServiceClient getClient();
    }

    public interface IClientFlowService1 : IClientService { }
    public interface IClientFlowService2 : IClientService { }
}

ClientFlowService.cs

using Azure.Identity;
using Microsoft.Graph;

namespace WebMvcException.Services
{
    public class ClientFlowService : IClientFlowService1
    {
        public GraphServiceClient getClient()
        {
            var scopes = new[] { "https://graph.microsoft.com/.default" };
            var tenantId = "yyy";
            var clientId = "yyy";
            var clientSecret = "yyy";
            var clientSecretCredential = new ClientSecretCredential(
                            tenantId, clientId, clientSecret);
            var graphClient = new GraphServiceClient(clientSecretCredential, scopes);
            return graphClient;
        }
    }

    public class ClientFlowService2 : IClientFlowService2
    {
        public GraphServiceClient getClient()
        {
            var scopes = new[] { "https://graph.microsoft.com/.default" };
            var tenantId = "xx";
            var clientId = "xx";
            var clientSecret = "xx";
            var clientSecretCredential = new ClientSecretCredential(
                            tenantId, clientId, clientSecret);
            var graphClient = new GraphServiceClient(clientSecretCredential, scopes);
            return graphClient;
        }
    }
}