Can't convert interface to concrete interface

Question

Why i can't convert implementation of interface which concrete implement generic interface? I need for Cat, Dog etc own interface realisation.

public interface IMarker { }
public class ResultA : IMarker
{
}
public class ResultB : IMarker
{ }

public interface IService<T> where T : IMarker
{
    public List<T> DoStuff();
}

public interface ICatService : IService<ResultA>
{ }
public interface IDogService : IService<ResultB>
{ }

public class CatService : ICatService
{
    public List<ResultA> DoStuff()
    {
        return new List<ResultA>();
    }
}

public class DogService : IDogService
{
    public List<ResultB> DoStuff()
    {
        return new List<ResultB>();
    }
}

public abstract class Animal
{
    protected readonly IService<IMarker> _svc;

    protected Animal(IService<IMarker> svc)
    {
        _svc = svc;
    }
}
public class Cat : Animal
{
    public Cat(ICatService svc) : base(svc)
    {
    }
}

public class Dog : Animal
{
    public Dog(ICatService svc) : base(svc)
    {
    }
}

CS1503 Argument 2: cannot convert from 'ICatService' to 'IService'

I have DI for services i.e. :

services.AddTransient<ICatService, CatService>();

score 3 · Accepted Answer · edited Feb 28 '23 at 22:01

The reason for such behaviour is that in general case IService<ResultA> is not IService<IMarker> (basically I would argue the same because C# classes do not support variance, for pretty good reason - see more here and here).

In this concrete case everything can be fixed by making the interface covariant and leveraging the covariance of IEnumerable<T>:

public interface IService<out T> where T : IMarker
{
    public IEnumerable<T> DoStuff();
}

public class CatService : ICatService
{
    public IEnumerable<ResultA> DoStuff() => return new List<ResultA>();
}

public class Cat : Animal
{
    public Cat(CatService svc) : base(svc)
    {
    }
}

But not sure that in your actual code you will be able to.

Or just make the base class generic (if this suits your use case):

public abstract class Animal<T> where T : IMarker
{
    protected readonly IService<T> _svc;

    protected Animal(IService<T> svc)
    {
        _svc = svc;
    }
}

Original answer

CatService does not implement ICatService, i.e. the fact that ICatService inherits only IService<ResultA> does not mean that they are the same, C# is strongly-typed (mostly :-) language and compiler will consider those two interfaces being different ones (though related). You need either to make CatService to implement ICatService:

public class CatService : ICatService
{
    // ...
}

Or register and resolve the IService<ResultA> interface (basically skipping intermediate interface at all):

services.AddTransient<IService<ResultA>, CatService>();

// ...

public Cat(IService<ResultA> svc) : base(svc){}

Sorry for confusing, in fact I meant that: CatService implements ICatService which implements IService. And in this case I get this error. — TryHard, Nov 28 '22 at 16:07
@TryHard what is `base(svc)`? What is the base class for `Cat`? — Guru Stron, Nov 28 '22 at 16:09
@TryHard see the update (this was actually discussed in your previous question in the second answer) — Guru Stron, Nov 28 '22 at 16:17
please could you check code now, i fixed it now it doesn't work ). I saw there was bad example. — TryHard, Nov 28 '22 at 16:18
@TryHard yep, I've already reconstructed your code an error and reflected it in the aforementioned update. — Guru Stron, Nov 28 '22 at 16:19

Can't convert interface to concrete interface

1 Answers1