.net core dependency injection breaks with generic interface

Question

Basically we have a Interface that takes another interface (constrained) When you create a hard implementation of that interface through a base class, the conversion fails as there is no implicit conversion.

I know that was probably hard to follow so we've gone ahead and made the simplest .NET 6 console app possible to show this issue.

Definition:

public interface IClient { }

public abstract class ClientBase : IClient { }

public class Client : ClientBase, IClient { }

public interface IServer where TClient : IClient { }

public abstract class ServerBase
    : IServer where TClient : IClient { }

public class Server : ServerBase { }

Console:

using Microsoft.Extensions.DependencyInjection;

namespace ConsoleApp;

public class Program
{
    public static IServiceCollection Services = new ServiceCollection();
    public static ServiceProvider Provider;

    public static void Main()
    {
        Services.AddSingleton();
        Services.AddSingleton, Server>();

        Provider = Services.BuildServiceProvider();
        var server = Provider.GetService>();
    }
}

Server can be type casted to an IServer

Client can be type casted to an IClient

But you cannot implicitly type case a Server instance to an IServer even though the base implementations all can be casted to those types.

I'm absolutely confused about this. We can fix it by changing DI to take an IServer but then one of our services which looks for ALL implementations of IServer cannot work anymore since we are providing a concrete implementation.

Jeroen van Langen · Answer

The problem is that the base class is not IServer but defined as IServer. Which cannot be implicitly converted. This is a common problem when using generics. :-(

This is a covariant problem. It will work when you define it with out:

public interface IServer where TClient : IClient
{

}

Covariance enables you to use a more derived type than that specified by the generic parameter. This allows for implicit conversion of classes that implement covariant interfaces and implicit conversion of delegate types.

.net core dependency injection breaks with generic interface

1 Answers