Using type constraints from inherited interface gives implicit reference conversion error

Question

I have this type constraint

where TLookup : ILookupable<ILookup>

And I'm passing this interface for the type

public interface IEmployeeProxy : ILookupableCode

Where you have

public interface ILookupableCode : ILookupable<ILookupCode>

And

public interface ILookupable<T> where T : ILookup
{
    Task<IEnumerable<T>> LookupByNameAsync(string name, int take = 5, int skip = 0);

    Task<T> LookupByIdAsync(long id);
}

And

public interface ILookupCode : ILookup

But I'm getting the There is no implicit reference conversion error and I don't know why, because for me IEmployeeProxy is

IEmployeeProxy => ILookupableCode => ILookupable<ILookupCode> => ILookupable<ILookup>

What I'm doing wrong here? Why I'm getting this error? For me looks like I should work.

If you want to know why I'm doing this, is because I want to have ILookupable with some methods that return ILookup, but also have ILookupableCode with the same methods of ILookupable that will return ILookupCode and a few more things too.

Just because two types, `T1` and `T2` exhibit a particular inheritance/implementation relationship, that *doesn't* imply that `G` and `G` will exhibit the *same* relationship. An `ILookupable` is *not* related to an `ILookupable`. It's possible it could be but that depends on whether the interfaces are amenable to co-/contra- variance. — Damien_The_Unbeliever, May 05 '20 at 14:28
@Damien_The_Unbeliever could explain better how `ILookupable` is not related to an `ILookupable` ? In what cases this would happen? — Vencovsky, May 05 '20 at 14:35
By default it's true. A `List` is not a `List`, because then someone can stick a `Giraffe` in there. — Damien_The_Unbeliever, May 05 '20 at 14:36
@Vencovsky [Covariance and Contravariance in C#](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/covariance-contravariance/) — Guru Stron, May 05 '20 at 14:37
Depending on *how* `ILookupable` uses it's `T` parameter there may be something possible here but we can't see how it's using `T`. — Damien_The_Unbeliever, May 05 '20 at 14:38
@Vencovsky it seems that you can try to change signature to `ILookupable ` — Guru Stron, May 05 '20 at 14:46
@Vencovsky given I, the fact that A : B doesn't mean that I is assignable to I. You need the generic parameter T in I to be covariant for this to work. That means I has to be defined as I. — Vladi Pavelka, May 05 '20 at 14:49
@GuruStron Are you guys sure? Because doing this `public interface ILookupable where T : ILookup` gives me this error `Invalid variance: The type parameter 'T' must be invariantly valid on 'ILookupable.LookupByIdAsync(long)'. 'T' is covariant.` — Vencovsky, May 05 '20 at 14:53
@Vencovsky well I'm not 100% sure what you are trying to model with ur intfcs, but I'm pretty sure what I wrote about I not being assignable to I holds. Try `List — Vladi Pavelka, May 05 '20 at 14:58
@VladiPavelka Now I understand why this doesn't work. Your example of `List` and `IEnumerable` works because `IEnumerable — Vencovsky, May 05 '20 at 15:14
@VladiPavelka This [question](https://stackoverflow.com/questions/30996986/why-is-taskt-not-co-variant) ask what I'm asking now — Vencovsky, May 05 '20 at 15:16
@Vencovsky may be [this](https://github.com/jam40jeff/ITask) will be useful for you. — Guru Stron, May 05 '20 at 15:42
Does this answer your question? [Why is Task not co-variant?](https://stackoverflow.com/questions/30996986/why-is-taskt-not-co-variant) — Julian, May 05 '20 at 15:47

score 0 · Answer 1 · answered May 05 '20 at 16:43

So the way to fix this would be change the signature of ILookupable to ILookupable<out T> but this comes with another problem what to do that, my methods need to return an interface type. So this makes impossible to have a method with return type Task<T> .

The only walkaround this is using this third party implementation of ITask.

Using type constraints from inherited interface gives implicit reference conversion error

1 Answers1