Title: Covariance and Contravariance in C#3

A short introduction to Covariance and Contravariance in *C# 3* preparing
you to an article about that in *C# 4*. So what is covariance?
Covariance is basically using a method which returns something derived
from the expected type. An exemple? It's safe to have a method
returning a cat when you expect it to return an animal. In C sharp it's

    :::csharp
    public class Animal
    {
    }

    public class Cat : Animal
    {
    }

    public class Dog : Animal
    {
    }

    // It's safe to say that something returns a Animal when in fact this thing returns a Cat
    class Covariance
    {
        void test()
        {
            Func a = Method; // OK
            Func b = delegate { return new Cat(); }; // OK
            Func c = () => new Cat(); // OK
        }

        Cat Method()
        {
            return new Cat();
        }
    }

So Funcs `a`, `b`, and `c` are returning animals which in fact are
cats, which is true. And, what is contravariance? Contravariance is
basically using a method which takes something which is a parent of
the expected type.  An exemple? It's safe to give a method an animal
when it expects to receive a cat.

    :::csharp
    // It's safe to say that something can take a Cat if in fact this thing can take any Animal
    class Contravariance
    {
        static void test()
        {
            Action a = Method; // OK
            Action b = delegate(Animal value) { }; // ERROR
            // From C#3 Specification :
            // $7.14.1 Anonymous function signatures :
            // [...] contra-variance of anonymous function parameter types is not supported.
            Action d = (Animal value) => { }; // idem... anonymous... not supported.
        }

        public static void Method(Animal value)
        {
        }
    }

So `Action` `a` take `Cats`, but in fact can take any `Animals`, so it's safe.