Covarience And ContraVariance

using System;
using System.Collections.Generic;
using System.IO;

namespace CovarientAndContraVarient
{
    class Program
    {
        static object GetObject() { return null; }
        static void SetObject(object obj) { }

        static string GetString() { return ""; }
        static void SetString(string str) { }

        static void Main(string[] args)
        {
            Func<object> getString = GetString;

            Action<string> setString = SetObject;

            Func<string> getString1 = GetString;

            //1. Delegate variable implicitly cast is not valid until .net 4.0
            Func<object> setString2 = getString1;

            //Assignment compatibility,
            IEnumerable<String> test = new List<string>();

            //covariance   OUT == > Covariance
            IEnumerable<object> test1 = new List<string>();

            //Assignment compatibility
            Action<Object> objAction = StaticMethod;

            //ContraConvariance , IN === > ContraConvariance
            Action<String> stringAction = StaticMethod;

            //2. Array Covariance, support in C# 1.0
            object[] objArray = new String[] { "a", "b", "c" };

            //Covariance in array is not safe, below code will throw exception
            objArray[0] = 5;

            //3. Co/contra- Variance don't support value type, below code is invalid
            //IEnumerable<object> objects = new List<int>();

            //you can use an interface instance that has methods with more 
            //derived return types than originally specified (covariance--OUT) 
            //or that has methods with less derived parameter types (contravariance--IN).

            //Contravariance
            IMyTest<FileStream> myTestInstance = new MyTestClass1<Stream>();

            IMyTest<Stream> myTest = new MyTestClass1<Stream>();

            //covariance
            IMyTest1<object> myTest1Instance = new MyTestClass2<string>();

            IMyTest<FileStream> myTestInstance1 = myTest;

            //Below Code, you will think it is a little strange, but absolutely it works well!!!!!!!!!
            //4. You can mark a generic type parameter as covariant if it is used only as a method return 
            //type and is not used as a type of formal method parameters.
            //5. And vice versa, you can mark a type as contravariant if it is used only as a type of 
            //formal method parameters and not used as a method return type.
            IMyFirstTestClass<object, string> testClass = null;
            IMyFirstTestClass<string, object> testClass1 = testClass;
        }

        public static void StaticMethod(object o)
        {
        }
    }

    public interface IMyFirstTestClass<in T1, out T2>
    {
        T2 DoSomething(T1 para);
    }



    //6. Variant type only can declared in interfaces and delegates only!!!!!!!
    //public class MyTestClass<in T>
    //{

    //}

    //Contravariance
    public interface IMyTest<in T>
    {
        void PrintTest(T param);
    }

    //7. Below code, T is invariance, if you want to it be Contravariance, you must declare it explicitly.
    //Same as covariance
    public interface IMyTestExtend<T> : IMyTest<T>
    {
    }

    public class MyTestClass1<T> : IMyTest<T>
    {
        public void PrintTest(T para)
        {
            Console.WriteLine("This is " + typeof(T) + " PrintTest Method!");
        }
    }

    //Covariance
    public interface IMyTest1<out T>
    {
        T PrintTest();
    }

    public class MyTestClass2<T> : IMyTest1<T>
    {
        public T PrintTest()
        {
            Console.WriteLine("This is " + typeof(T) + " PrintTest Method!");
            return default(T);
        }
    }

    public delegate void MyHander<in T>(T para);

    //Below method declaration is invalid,  because 'in' is contravariance, it only can be in paramter type
    //public delegate T MyHander1<in T>(T para);

    public delegate T MyHandler2<out T>(object para);

    //Below method declaration is invalid, because 'out' is covariance,  it only can be in returned type
    //public delegate void MyHandler2<out T>(T para);

}

 FYI: http://blogs.msdn.com/b/csharpfaq/archive/2010/02/16/covariance-and-contravariance-faq.aspx