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的类型参数
 public class ClassT1 { }
 //作为TName2的类型参数
 public class ClassT2 :BaseClass,IInterfaceA, IInterfaceB { }
 public class ReflectionT
 {
  public void CreateGeneric()
  {
   //创建一个名为”ReflectionT“的动态程序集，这个程序集可以执行和保存。
   AppDomain myDomain = AppDomain.CurrentDomain;
   AssemblyName assemblyName = new AssemblyName("ReflectionT");
   AssemblyBuilder assemblyBuilder = myDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);
   //在这个程序集中创建一个与程序集名相同的模块，接着创建一个类MyClass。
   ModuleBuilder moudleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName.Name, assemblyName.Name + ".dll");
   TypeBuilder myType = moudleBuilder.DefineType("MyClass", TypeAttributes.Public);
   //创建类型参数名，将达到这样的效果：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);       //方法的参数
   //为方法添加方法体
   Type ienumOf = typeof(IEnumerable<>);
   Type TFromListOf = listType.GetGenericArguments()[0];
   Type ienumOfT = ienumOf.MakeGenericType(TFromListOf);
   Type[] ctorArgs = { ienumOfT };
   ConstructorInfo cInfo = listType.GetConstructor(ctorArgs);
   //最终的目的是要调用List<TName1>的构造函数 : 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);
   //创建并保存程序集
   Type finished = myType.CreateType();
   assemblyBuilder.Save(assemblyName.Name + ".dll");
   //创建这个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);
   //查看返回结果中的数量和完全限定名
   Console.WriteLine(listResult.Count);
   Console.WriteLine(listResult[0].GetType().FullName);
   //查看类型参数以及约束
   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;
   //为了能够进行转换，于是出现了协变与逆变
   IOut<object> oBase2 = new MyClass<object>();
   IOut<string> o2 = new MyClass<string>();
   //o2 = oBase2; 编译不通过
   //有了out关键字的话，就可以实现从IOut<string>到IOut<object>的转换-往父类转换
   oBase2 = o2;
   IIn<object> oBase3 = new MyClass<object>();
   IIn<string> o3 = new MyClass<string>();
   //oBase3 = o3; 编译不通过
   //有了in关键字的话，就可以实现从IIn<object>到IOut<string>的转换-往子类转换
   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能够转换为o
   //o = str;
   object o1=new object();
   //这样的话就是object类型向string类型转换了，类型不安全
   o.Function1(o1);
   //这样则是string类型向object类型转换了，注意这样是ok的，没什么问题
   object o2=o.Function2();
   //假设str能够转换为o
   //str=o;
   //string对象将转变为object，这样没问题
   str.Function1("haha");
   //这样将是object向string类型的转换，类型不安全。
   string o3=str.Function2();
  }
 }