Comment la covérité est-elle plus fraîche que le polymorphisme ... et non redondante?

.NET 4 introduit la covariance. Je suppose que c'est utile. Après tout, les États membres ont traversé toutes les difficultés de l'ajouter à la langue C #. Mais pourquoi la covariance est-elle plus utile que le bon vieux polymorphisme?

J'ai écrit cet exemple pour comprendre pourquoi je devrais mettre en œuvre la covariance, mais je ne l'obtiens toujours pas. S'il vous plaît éclairer moi. P>

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Sample
{
    class Demo
    {
        public delegate void ContraAction<in T>(T a);

        public interface IContainer<out T>
        {
            T GetItem();
            void Do(ContraAction<T> action);
        }

        public class Container<T> : IContainer<T>
        {
            private T item;

            public Container(T item)
            {
                this.item = item;
            }

            public T GetItem()
            {
                return item;
            }

            public void Do(ContraAction<T> action)
            {
                action(item);
            }
        }

        public class Shape
        {
            public void Draw()
            {
                Console.WriteLine("Shape Drawn");
            }
        }

        public class Circle:Shape
        {
            public void DrawCircle()
            {
                Console.WriteLine("Circle Drawn");
            }
        }

        public static void Main()
        {
            Circle circle = new Circle();
            IContainer<Shape> container = new Container<Circle>(circle);
            container.Do(s => s.Draw());//calls shape

            //Old school polymorphism...how is this not the same thing?
            Shape shape = new Circle();
            shape.Draw();
        }
    }
}