c# .net 4.0 Covariant vs Contravariant

Question

I'm trying to get something working and struggling with the below when using Contravariance. My understanding is Covariance is where you can return a derived type from a base type. Contravariance is where you can pass in a derived type from a base type as an argument into a class.

So I have the below interface (contravariant):

public interface IBase<in T> where T: BaseModel
{
        void Process(T model);
}

I then have an abstract class

public abstract class Base<T>: IBase<T> where T: BaseModel
{
    public virtual void Process(T model)
    {
       // throw new System.NotImplementedException();
    }
}

and another concrete class

public class Parent: Base<ParentModel>
{
    public override void Process(ParentModel model)
    {
        // throw new System.NotImplementedException();
    }
}

Considering the generic type is only ever used as an input and not a return type, I don't see why I cannot do the below:

IBase<BaseModel> baseContravariant = new  Parent();
// This doesn't compile. I will eventually have a list of IBase<BaseMode> to which I'd like to pass in different parent instances.

I have another example using covariance which is below and works fine.

public interface IBase<out T> where T : BaseModel, new()
{
    T ProcessAndGet();
}

Abstract

public abstract class Base<T>: IBase<T> where T: BaseModel, new()
{
    public virtual T ProcessAndGet()
    {
        var result = new T() as BaseModel;

        // More shizzle here
        return (T)result;
    }
}

Concrete

public class Parent : Base<ParentModel>
{ 
    public override ParentModel ProcessAndGet()
    {
        var x = base.ProcessAndGet();
        return x;
    }
}

Now I can do

IBase<BaseModel> baseInstance = new Base<BaseModel>();
IBase<BaseModel> derived = new Parent();
baseInstance = derived;

There's more code to the above examples but I've removed it for ease of reading (hopefully!) :-)

Martin Ullrich · Accepted Answer · 2017-06-07T20:19:50.730

0

Contravariance in this case means that you need to pass in types that are of the specified type or one that is "more specialised" (=> derive from the base type).

Since your Parent implementation in your first example can only process ParentModel, it is invalid to pass in a BaseModel instance. Trying to do new Parent().Process(new BaseModel()) also would not compile. So it is invalid to cast it to IBase<BaseModel>. (assuming ParentModel is a subclass of BaseModel).

In this case the contravariance model is easier to reason about by thinking that an IBase<in T> "consumes a T". So an IBase<ParentModel> "consumes ParentModels". This means it can only be passed values that are instances of ParentModel or can be treated as one (effectively only subclasses).

In your second example you are using <out T>, which is "covariant". This can be described as "it produces instances of T". So a class that "produces" a ParentModel is automatically a "producer" of BaseModel as well: since ParentModel can be cased to BaseModel, IBase<ParentModel> can be casted to IBase<BaseModel> as well.

edited Jun 07 '17 at 20:19

answered Jun 07 '17 at 19:54

Martin Ullrich

94,744
25
252
217

Thanks for the response and informative answer. The second example I provided does a similar thing in terms of steps. The Parent class only takes in ParentModel but I can still assign this to the base class? I thought that was the intent behind the in/out feature... – tones Jun 07 '17 at 20:15
I added a paragraph about to covariant type. I'm not quite sure what your actual question for that is to be honest.. (other than explaining it in easier words. replacing everything with "producer" and "consumer" always helped me figure this stuff out) – Martin Ullrich Jun 07 '17 at 20:21
Aah that makes sense. There wasn't a question about the second point. It was like you say more to compare the two for understanding as one worked and the other didn't. In short for covariance you can assign to less specific types but contravariance you cannot. Hopefully I understood that correctly. – tones Jun 07 '17 at 20:30
yes that is what it means in these cases. "co" and "contra" are really just syllables to distinguish the different "direction" of inheritance / casting+assignment – Martin Ullrich Jun 07 '17 at 20:43

c# .net 4.0 Covariant vs Contravariant

1 Answers1