using System;

using System.Collections.Generic;

​

public interface ICovariant<out T> {}

public interface IContravariant<in T> {}

public class Covariant<T> : ICovariant<T> { }

public class Contravariant<T> : IContravariant<T> { }

​

public class Animal { }

public class Dog : Animal { }

public class Cat : Animal { }

​

​

public class Program

{

    public delegate Animal AnimalDelegate();

    public delegate Animal AnotherAnimalDelegate(Dog d);

    public static Cat CatMethod() { return null; }  

    public static Animal DogMethod(Animal a) { return null; }

    public static void Main()

    {

        // Covariance

        var cats = new List<Cat>(); // Instantiated more derived type.

        var animals = cats; // Assigned to less derived type.

        // Contravariance

        var moreAnimals = new List<Animal>(); // Instantiated less derived type.

        var moreCats = moreAnimals; // Assigned to more derived type.

        // Delegate Covariance

        AnimalDelegate ad = CatMethod; // Can assign method with more derived return type to less derived (delegate) return type.

        // Delegate Contravariance

        AnotherAnimalDelegate aad = DogMethod; // Can assign method with less derived param type to more derived (delegate) param type.

        // Generic Convariant

        ICovariant<Animal> animalOne = new Covariant<Animal>();

        ICovariant<Dog> dog = new Covariant<Dog>();

        animalOne = dog; // Animal is being upcasted to dog.  Need OUT keyword to work.

        // Generic Contravariant

        IContravariant<Animal> animalTwo = new Contravariant<Animal>();

        IContravariant<Cat> cat = new Contravariant<Cat>();

        cat = animalTwo; // Cat is being downcasted to animal, need IN keyword to work.

    }

}