Registering service that implements several interfaces as singleton using open generic type

Question

There is a generic MyClass that implements 2 generic interfaces IMyInterface1 and IMyInterface2. I want to register it as a singleton. So for a given T both interfaces will be resolved to the same instance of MyClass.

I'm trying to register it as open generic type with forwarding to a factory method:

services.AddSingleton(typeof(MyClass<>));
services.AddSingleton(typeof(IMyInterface1<>), sp => sp.GetRequiredService(typeof(MyClass<>)));
services.AddSingleton(typeof(IMyInterface2<>), sp => sp.GetRequiredService(typeof(MyClass<>)));

but then in runtime I'm getting exception with message "Open generic service type 'IMyInterface1`1[T]' requires registering an open generic implementation type."

When I'm registering my singleton for every concrete type T, i.e. without open generic type, all works fine:

services.AddSingleton(typeof(MyClass));
services.AddSingleton(typeof(IMyInterface1), sp => sp.GetRequiredService(typeof(MyClass)));
services.AddSingleton(typeof(IMyInterface2), sp => sp.GetRequiredService(typeof(MyClass)));
services.AddSingleton(typeof(MyClass));
services.AddSingleton(typeof(IMyInterface1), sp => sp.GetRequiredService(typeof(MyClass)));
services.AddSingleton(typeof(IMyInterface2), sp => sp.GetRequiredService(typeof(MyClass)));

user_8399253 · Answer

It looks like you can't do this - it's not supported.

The following issues look to have already requested this:

If you replace sp => sp.GetRequiredService(typeof(MyClass)) on the interface registrations with typeof(MyClass) then you will end up with a singleton instance for each interface you've registered, which doesn't sound like what you want.

The best I can think of, and it's not particularly pretty, is that you turn MyClass into a facade that manages its own singleton instance of the underlying implementation. You could do this by having the facade call into a non-generic class with a static dictionary (static members are per-generic type so this needs to be a non-generic class) to retrieve a truly singleton instance per T.

Example

Register your services:

services.AddSingleton(typeof(MyFacadeClass<>));
services.AddSingleton(typeof(IMyInterface1<>), typeof(MyFacadeClass<>));
services.AddSingleton(typeof(IMyInterface2<>), typeof(MyFacadeClass<>));

Facade implementation:

public class MyImplementationClass : IMyInterface1, IMyInterface2
{
    public void Interface1Method()
    {
    }

    public void Interface2Method()
    {
    }
}

public class MyClassSingletonRegister
{
    public static Dictionary MyImplementationClassInstances = new Dictionary();
}

public class MyFacadeClass : IMyInterface1, IMyInterface2
{
    private readonly MyImplementationClass _instance;

    public MyFacadeClass()
    {
        _instance = GetInstance();
    }

    private MyImplementationClass GetInstance()
    {
        if (!MyClassSingletonRegister.MyImplementationClassInstances.TryGetValue(typeof(T), out var instance))
        {
            Debug.WriteLine("Creating new instance for " + typeof(T).Name);
            var myImplementationClass = new MyImplementationClass();
            MyClassSingletonRegister.MyImplementationClassInstances.Add(typeof(T), myImplementationClass);

            instance = myImplementationClass;
        }

        return (MyImplementationClass) instance;
    }


    public void Interface1Method()
    {
        _instance.Interface1Method();
    }

    public void Interface2Method()
    {
        _instance.Interface2Method();
    }
}

public interface IMyInterface1
{
    void Interface1Method();
}

public interface IMyInterface2
{
    void Interface2Method();
}

Registering service that implements several interfaces as singleton using open generic type

1 Answers