Question

• Assuming

  class A
  { }

  class B : A
  { }

covariance is not supported for generic class.

Meaning – we cant do something like this :

MyConverter<B> x1= new MyConverter<B>();
MyConverter<A> x2= x1;  

Thats fine and understood.

From my reading – i understand that Covariance will be available:

“If you use a backing Generic Interface Being implemented on a Generic Class – so that access to the T type object instance will be available through those interfaces “.

I have just one problem.

Ive seen many examples of the “converter” class as a form of Stack .

But never understood ” what if I want to use only 1 instance of B from a reference of A ? “

so Ive tried some code :

Create B object + values —> use Generic Converter for B —>
use the covariance flow to get its A reference —> now you can use it
either as A or as B.

My question :

Is That the correct way of doing this ( for using covariance for 1 object only ) ?

p.s.
The code is working and compiled ok. https://i.stack.imgur.com/PJ6QO.png

Ive been asking /reading a lot about this topic lately – I dive into things in order to understand them the best I can.

Answer 1

Your code compiles and works, so is it “correct”? I guess it is!

However it is not very interesting having a stack that only contains a single element; that’s not really a stack. Let’s think about how you might make a truly covariant and contravariant stack.

interface IPush<in T> { void Push(T item); }
interface IPop<out T> { T Pop(); }
class Stack<T> : IPush<T>, IPop<T>
{
    private class Link
    {
        public T Item { get; private set; }
        public Link Next { get; private set; }
        public Link(T item, Link next) { this.Item = item; this.Next = next; }
    }

    private Link head;
    public Stack() { this.head = null; }

    public void Push(T item)
    {
        this.head = new Link(item, this.head);
    }

    public T Pop()
    {
        if (this.head == null) throw new InvalidOperationException();
        T value = this.head.Item;
        this.head = this.head.Next;
        return value;
    }
}

And now you can use the stack covariantly for popping, and contravariantly for pushing:

Stack<Mammal> mammals = new Stack<Mammal>();
IPop<Animal> animals = mammals;
IPush<Giraffe> giraffes = mammals;
IPush<Tiger> tigers = mammals;
giraffes.Push(new Giraffe());
tigers.Push(new Tiger());
System.Console.WriteLine(animals.Pop()); // Tiger
System.Console.WriteLine(animals.Pop()); // Giraffe

What if I want to use only one instance of B from a reference of A?

Your question is “what if I want to use a Tiger but I have a reference an Animal?” The answer is “you can’t” because the Animal might not be a Tiger! If you want to test whether the reference to Animal is really a tiger then say:

Tiger tiger = myAnimal as Tiger;
if (tiger != null) ...

or

if (myAnimal is Tiger) ...

What about if you want to convert class C<B> to C<A>?

That’s not possible. There is no reference conversion there. The only covariant and contravariant reference conversions in C# 4 are on generic interfaces and generic delegates that are constructed with reference types as the type arguments. Generic classes and structs may not be used covariantly or contravariantly. The best thing you can do is make the class implement a variant interface.