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[] = ;
 
             //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