Covarience And ContraVariance

  1 using System;
  2 using System.Collections.Generic;
  3 using System.IO;
  4 
  5 namespace CovarientAndContraVarient
  6 {
  7     class Program
  8     {
  9         static object GetObject() { return null; }
 10         static void SetObject(object obj) { }
 11 
 12         static string GetString() { return ""; }
 13         static void SetString(string str) { }
 14 
 15         static void Main(string[] args)
 16         {
 17             Func<object> getString = GetString;
 18 
 19             Action<string> setString = SetObject;
 20 
 21             Func<string> getString1 = GetString;
 22 
 23             //1. Delegate variable implicitly cast is not valid until .net 4.0
 24             Func<object> setString2 = getString1;
 25 
 26             //Assignment compatibility,
 27             IEnumerable<String> test = new List<string>();
 28 
 29             //covariance   OUT == > Covariance
 30             IEnumerable<object> test1 = new List<string>();
 31 
 32             //Assignment compatibility
 33             Action<Object> objAction = StaticMethod;
 34 
 35             //ContraConvariance , IN === > ContraConvariance
 36             Action<String> stringAction = StaticMethod;
 37 
 38             //2. Array Covariance, support in C# 1.0
 39             object[] objArray = new String[] { "a", "b", "c" };
 40 
 41             //Covariance in array is not safe, below code will throw exception
 42             objArray[0] = 5;
 43 
 44             //3. Co/contra- Variance don't support value type, below code is invalid
 45             //IEnumerable<object> objects = new List<int>();
 46 
 47             //you can use an interface instance that has methods with more 
 48             //derived return types than originally specified (covariance--OUT) 
 49             //or that has methods with less derived parameter types (contravariance--IN).
 50 
 51             //Contravariance
 52             IMyTest<FileStream> myTestInstance = new MyTestClass1<Stream>();
 53 
 54             IMyTest<Stream> myTest = new MyTestClass1<Stream>();
 55 
 56             //covariance
 57             IMyTest1<object> myTest1Instance = new MyTestClass2<string>();
 58 
 59             IMyTest<FileStream> myTestInstance1 = myTest;
 60 
 61             //Below Code, you will think it is a little strange, but absolutely it works well!!!!!!!!!
 62             //4. You can mark a generic type parameter as covariant if it is used only as a method return 
 63             //type and is not used as a type of formal method parameters.
 64             //5. And vice versa, you can mark a type as contravariant if it is used only as a type of 
 65             //formal method parameters and not used as a method return type.
 66             IMyFirstTestClass<object, string> testClass = null;
 67             IMyFirstTestClass<string, object> testClass1 = testClass;
 68         }
 69 
 70         public static void StaticMethod(object o)
 71         {
 72         }
 73     }
 74 
 75     public interface IMyFirstTestClass<in T1, out T2>
 76     {
 77         T2 DoSomething(T1 para);
 78     }
 79 
 80 
 81 
 82     //6. Variant type only can declared in interfaces and delegates only!!!!!!!
 83     //public class MyTestClass<in T>
 84     //{
 85 
 86     //}
 87 
 88     //Contravariance
 89     public interface IMyTest<in T>
 90     {
 91         void PrintTest(T param);
 92     }
 93 
 94     //7. Below code, T is invariance, if you want to it be Contravariance, you must declare it explicitly.
 95     //Same as covariance
 96     public interface IMyTestExtend<T> : IMyTest<T>
 97     {
 98     }
 99 
100     public class MyTestClass1<T> : IMyTest<T>
101     {
102         public void PrintTest(T para)
103         {
104             Console.WriteLine("This is " + typeof(T) + " PrintTest Method!");
105         }
106     }
107 
108     //Covariance
109     public interface IMyTest1<out T>
110     {
111         T PrintTest();
112     }
113 
114     public class MyTestClass2<T> : IMyTest1<T>
115     {
116         public T PrintTest()
117         {
118             Console.WriteLine("This is " + typeof(T) + " PrintTest Method!");
119             return default(T);
120         }
121     }
122 
123     public delegate void MyHander<in T>(T para);
124 
125     //Below method declaration is invalid,  because 'in' is contravariance, it only can be in paramter type
126     //public delegate T MyHander1<in T>(T para);
127 
128     public delegate T MyHandler2<out T>(object para);
129 
130     //Below method declaration is invalid, because 'out' is covariance,  it only can be in returned type
131     //public delegate void MyHandler2<out T>(T para);
132 
133 }