class Program
 {
  static void Main(string[] args)
  {
   MyList<int> listInt = new MyList<int>();
   MyList<string> listString = new MyList<string>();
   listInt.Add(24);
   listInt[1] = 5;
   listString[2] = "ha ha";
  }
 }
 public class MyList<T>
 {
  T[] array;
  int current = -1;
  public MyList()
  {
   array = new T[10];
  }
  public void Add(T t)
  {
   current++;
   if (current < 10)
    array[current] = t;
  }
  public T this[int index]
  {
   get
   {
    return array[index];
   }
   set
   {
    array[index] = value;
   }
  }
 }

public class BaseClass { }
 public interface IInterfaceA { }
 public interface IInterfaceB { }
 //作為TName1的類型參數(shù)
 public class ClassT1 { }
 //作為TName2的類型參數(shù)
 public class ClassT2 :BaseClass,IInterfaceA, IInterfaceB { }
 public class ReflectionT
 {
  public void CreateGeneric()
  {
   //創(chuàng)建一個名為”ReflectionT“的動態(tài)程序集，這個程序集可以執(zhí)行和保存。
   AppDomain myDomain = AppDomain.CurrentDomain;
   AssemblyName assemblyName = new AssemblyName("ReflectionT");
   AssemblyBuilder assemblyBuilder = myDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);
   //在這個程序集中創(chuàng)建一個與程序集名相同的模塊，接著創(chuàng)建一個類MyClass。
   ModuleBuilder moudleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName.Name, assemblyName.Name + ".dll");
   TypeBuilder myType = moudleBuilder.DefineType("MyClass", TypeAttributes.Public);
   //創(chuàng)建類型參數(shù)名，將達到這樣的效果：public MyClass<TParam1,TParam2>
   string[] tNames = { "TName1", "TName2" };
   GenericTypeParameterBuilder[] gtps = myType.DefineGenericParameters(tNames);
   GenericTypeParameterBuilder tName1 = gtps[0];
   GenericTypeParameterBuilder tName2 = gtps[1];
   //為泛型添加約束，TName1將會被添加構造器約束和引用類型約束
   tName1.SetGenericParameterAttributes(GenericParameterAttributes.DefaultConstructorConstraint | GenericParameterAttributes.ReferenceTypeConstraint);
   //TName2達到的效果將是：where TName2:ValueType,IComparable,IEnumerable
   Type baseType = typeof(BaseClass);
   Type interfaceA = typeof(IInterfaceA);
   Type interfaceB = typeof(IInterfaceA);
   Type[] interfaceTypes = { interfaceA, interfaceB };
   tName2.SetBaseTypeConstraint(baseType);
   tName2.SetInterfaceConstraints(interfaceTypes);
   /*為泛型類MyClass添加字段：
   private string name;
   public TName1 tField1;
    */
   FieldBuilder fieldBuilder = myType.DefineField("name", typeof(string), FieldAttributes.Public);
   FieldBuilder fieldBuilder2 = myType.DefineField("tField1", tName1, FieldAttributes.Public);
   //為泛型類添加方法Hello
   Type listType = typeof(List<>);
   Type ReturnType = listType.MakeGenericType(tName1);
   Type[] parameter = { tName1.MakeArrayType() };
   MethodBuilder methodBuilder = myType.DefineMethod(
    "Hello",        //方法名
    MethodAttributes.Public | MethodAttributes.Static, //指定方法的屬性
    ReturnType,      //方法的放回類型
    parameter);       //方法的參數(shù)
   //為方法添加方法體
   Type ienumOf = typeof(IEnumerable<>);
   Type TFromListOf = listType.GetGenericArguments()[0];
   Type ienumOfT = ienumOf.MakeGenericType(TFromListOf);
   Type[] ctorArgs = { ienumOfT };
   ConstructorInfo cInfo = listType.GetConstructor(ctorArgs);
   //最終的目的是要調(diào)用List<TName1>的構造函數(shù) : new List<TName1>(IEnumerable<TName1>);
   ConstructorInfo ctor = TypeBuilder.GetConstructor(ReturnType, cInfo);
   //設置IL指令
   ILGenerator msil = methodBuilder.GetILGenerator();
   msil.Emit(OpCodes.Ldarg_0);
   msil.Emit(OpCodes.Newobj, ctor);
   msil.Emit(OpCodes.Ret);
   //創(chuàng)建并保存程序集
   Type finished = myType.CreateType();
   assemblyBuilder.Save(assemblyName.Name + ".dll");
   //創(chuàng)建這個MyClass這個類
   Type[] typeArgs = { typeof(ClassT1), typeof(ClassT2) };
   Type constructed = finished.MakeGenericType(typeArgs);
   object o = Activator.CreateInstance(constructed);
   MethodInfo mi = constructed.GetMethod("Hello");
   ClassT1[] inputParameter = { new ClassT1(), new ClassT1() };
   object[] arguments = { inputParameter };
   List<ClassT1> listResult = (List<ClassT1>)mi.Invoke(null, arguments);
   //查看返回結果中的數(shù)量和完全限定名
   Console.WriteLine(listResult.Count);
   Console.WriteLine(listResult[0].GetType().FullName);
   //查看類型參數(shù)以及約束
   foreach (Type t in finished.GetGenericArguments())
   {
    Console.WriteLine(t.ToString());
    foreach (Type c in t.GetGenericParameterConstraints())
    {
     Console.WriteLine(" "+c.ToString());
    }
   }
  }
 }

public interface INone<T> { }
  public interface IOut<out T> { }
  public interface IIn<in T> { }
  public class MyClass<T> : INone<T>, IOut<T>, IIn<T> { }
  void hh()
  {
   INone<object> oBase1 = new MyClass<object>();
   INone<string> o1 = new MyClass<string>();
   //下面兩句都無法編譯通過
   //o1 = oBase1;
   //oBase1 = o1;
   //為了能夠進行轉(zhuǎn)換，于是出現(xiàn)了協(xié)變與逆變
   IOut<object> oBase2 = new MyClass<object>();
   IOut<string> o2 = new MyClass<string>();
   //o2 = oBase2; 編譯不通過
   //有了out關鍵字的話，就可以實現(xiàn)從IOut<string>到IOut<object>的轉(zhuǎn)換-往父類轉(zhuǎn)換
   oBase2 = o2;
   IIn<object> oBase3 = new MyClass<object>();
   IIn<string> o3 = new MyClass<string>();
   //oBase3 = o3; 編譯不通過
   //有了in關鍵字的話，就可以實現(xiàn)從IIn<object>到IOut<string>的轉(zhuǎn)換-往子類轉(zhuǎn)換
   o3 = oBase3;
  }

public interface INone<T>
 {
  void Function1(T tParam);
  T Function2();
 }
 class MyClass<T> : INone<T>
 {
  public void Function1(T tParam)
  {
   Console.WriteLine(tParam.ToString());
  }
  public T Function2()
  {
   T t = default(T);
   return t;
  }
 }
 class hhh
 {
  void fangyz()
  {
   INone<object> o = new MyClass<object>();
   INone<string> str = new MyClass<string>();
   //假設str能夠轉(zhuǎn)換為o
   //o = str;
   object o1=new object();
   //這樣的話就是object類型向string類型轉(zhuǎn)換了，類型不安全
   o.Function1(o1);
   //這樣則是string類型向object類型轉(zhuǎn)換了，注意這樣是ok的，沒什么問題
   object o2=o.Function2();
   //假設str能夠轉(zhuǎn)換為o
   //str=o;
   //string對象將轉(zhuǎn)變?yōu)閛bject，這樣沒問題
   str.Function1("haha");
   //這樣將是object向string類型的轉(zhuǎn)換，類型不安全。
   string o3=str.Function2();
  }
 }