In C# how to inject all instances of generic interface into a single constructor using the generic's base class?

user_9100849 0
Viewed 312

I have defined the following interface:

public interface ICustomService<T> where T : CustomObject
{
   IEnumerable<T> GetById(int Id);
   ...
}

And 2 implementations of it where MyObject1 & MyObject2 both inherit from CustomObject

public class CustomService1 : ICustomService<MyObject1>
{
    public IEnumerable<MyObject1> GetById(int Id)
    {
        ...
    }
}

public class CustomService2 : ICustomService<MyObject2>
{
    public IEnumerable<MyObject2> GetById(int Id)
    {
        ...
    }
}

I try registering both of these as ICustomService<CustomObject> but get the error:

There is no implicit reference conversion from 'CustomerService1' to 'ICustomService<CustomObject>'

Instead registering like this:

services.AddTransient<ICustomService<MyObject1>, CustomService1>();
services.AddTransient<ICustomService<MyObject2>, CustomService2>();

When registering like above, my IEnumerable services is empty:

public ThirdService(IEnumerable<ICustomService<CustomObject>> services)
{
    
}

How can I inject all implementation of ICustomService into ThirdService?

I'm trying to do this so that ThirdService can be given an ID and then fetch all CustomObject with that Id using GetById on all the services.

dependency-injection interface generics .net c#
2 Answers

Assuming there are no additional interface methods that have parameters of type T, mutable properties of type T, or methods that return a generic type that uses T in a non-covariant way, you can make that T covariant using out:

public interface ICustomService<out T> where T : CustomObject

This would make your registration attempt valid:

services.AddTransient<ICustomService<CustomObject>, CustomService1>();
services.AddTransient<ICustomService<CustomObject>, CustomService2>();

Covariance ensures that CustomService1 and CustomService2 can safely be used in place of a ICustomService<CustomObject>, despite them both declaring a subclass of MyObject as the generic argument.

user_81263620

You could add a marker interface ICustomService

Interfaces:

// New marker interface
public interface ICustomService {}

// Derive marker interface
public interface ICustomService<T> : ICustomService where T : CustomObject
{
   IEnumerable<T> GetById(int Id);
   ...
}

Registrations:

services.AddTransient<ICustomService, CustomService1>();
services.AddTransient<ICustomService, CustomService2>();

Resolve dependency injected Services:

public ThirdService(IEnumerable<ICustomService> services)
{
    
}
user_73024980
Related