private static void SomeMethod()
{
  // 构造一个List来操作DateTime对象
  List<DateTime> dtList = new List<DateTime>();

  dtList.Add(DateTime.Now); //不进行装箱, 值类型

  dtList.Add("1/1/2004");   // 编译时错误,检查类型

  DateTime dt = dtList[0];  // 不需要转型
}

public static class Generics
{
    public static void Main()
    {
        Performance.ValueTypePerfTest();
        Performance.ReferenceTypePerfTest();
    }
}
internal static class Performance
{
    // 值类型的泛型类和非泛型类性能测试
    public static void ValueTypePerfTest()
    {
        const Int32 count = 100000000;

        // 泛型类List<Int32>性能测试
        // 运行性能计时器, 在using代码块结束后会DisPose停止计时
        using (new OperationTimer("List<Int32>"))
        {
            List<Int32> l = new List<Int32>();
            for (Int32 n = 0; n < count; n++)
            {
                l.Add(n);       // 不发生装箱
                Int32 x = l[n]; // 不发生拆箱
            }
            l = null; // 使引用为null,确保进行垃圾回收
        }
        // 非泛型类ArrayList<Int32>性能测试
        // 运行性能计时器, 在using代码块结束后会DisPose停止计时
        using (new OperationTimer("ArrayList of Int32"))
        {
            ArrayList a = new ArrayList();
            for (Int32 n = 0; n < count; n++)
            {
                a.Add(n);               // 装箱
                Int32 x = (Int32) a[n]; // 拆箱
            }
            a = null; // 使引用为null,确保进行垃圾回收
        }
    }
    // 引用类型的非泛型和泛型性能测试
    public static void ReferenceTypePerfTest()
    {
        const Int32 count = 100000000;

        using (new OperationTimer("List<String>"))
        {
            List<String> l = new List<String>();
            for (Int32 n = 0; n < count; n++)
            {
                // 字符串
                l.Add("X");      // Reference copy
                String x = l[n]; // Reference copy
            }
            l = null; // Make sure this gets GC'd
        }

        using (new OperationTimer("ArrayList of String"))
        {
            ArrayList a = new ArrayList();
            for (Int32 n = 0; n < count; n++)
            {
                // 字符串
                a.Add("X");               // Reference copy
                String x = (String) a[n]; // Cast check & reference copy
            }
            a = null; // Make sure this gets GC'd
        }
    }

    // 用于运行时性能计时
    private sealed class OperationTimer : IDisposable
    {
        private Stopwatch m_stopwatch;
        private String    m_text;
        private Int32     m_collectionCount;

        public OperationTimer(String text)
        {
            PrepareForOperation();

            m_text            = text;
            m_collectionCount = GC.CollectionCount(0);

            // This should be the last statement in this
            // method to keep timing as accurate as possible
            m_stopwatch = Stopwatch.StartNew();
        }

        // 在using代码块结束后会Dispose会执行
        public void Dispose()
        {
            Console.WriteLine("{0} (GCs={1,3}) {2}",
                (m_stopwatch.Elapsed),
                GC.CollectionCount(0) - m_collectionCount, m_text);
        }

        // 强制垃圾回收器执行
        private static void PrepareForOperation()
        {
            // 首先 GC.Collect(); 并不会立即去回收 只是告诉回收器 去回收
            // 垃圾收集器在一次垃圾收集过程中,垃圾收集器的逻辑不能保证所有未引用的对象都从堆中删除

            // 我们可以显式调用 GC.Collect();GC.WaitForPendingFinalizers();
            // 这两行代码进行强制回收的执行
            GC.Collect();
            // 挂起当前线程，直到处理终结器队列的线程清空该队列为止。
            GC.WaitForPendingFinalizers();
            GC.Collect();
        }
    }
}
// 00:00:00.6625861 (GCs=  6) List<Int32>
// 00:00:05.5150908 (GCs=388) ArrayList of Int32
// 00:00:01.1244509 (GCs=  1) List<String>
// 00:00:01.2407716 (GCs=  0) ArrayList of String

// 定义一个部分指定的开放类型
internal sealed class DictonaryStringKey<TValue> : Dictionary<String, TValue>
{
}

static void Main(string[] args)
{
    Object o = null;

    // Dictionary<,>有2个泛型参数,是开放类型,不允许创建实例
    Type t = typeof(Dictionary<,>);
    // 在运行时抛出异常, 创建失败
    o = CreateInstance(t);

    // DictonaryStringKey<>,有一个泛型参数没指定,所以是开放类型
    t = typeof(DictonaryStringKey<>);
    // 在运行时抛出异常, 创建失败
    o = CreateInstance(t);

    // 传入了确定的类型,就是封闭类型
    t = typeof(DictonaryStringKey<Guid>);
    // 创建成功
    o = CreateInstance(t);

    Console.WriteLine(o.GetType());
}

private static Object CreateInstance(Type t)
{
    Object o = null;
    try
    {
        o = Activator.CreateInstance(t);
        Console.WriteLine($"已创建{t.ToString()}的实例.");
    }
    catch (ArgumentException e)
    {
        Console.WriteLine(e.Message);
    }
    return o;
}
// 输出:
// Cannot create an instance of System.Collections.Generic.Dictionary`2[TKey,TValue] because Type.ContainsGenericParameters is true.
// Cannot create an instance of DictonaryStringKey`1[TValue] because Type.ContainsGenericParameters is true.
// 已创建DictonaryStringKey`1[System.Guid]的实例.
// DictonaryStringKey`1[System.Guid]

internal sealed class MyClass<T>
{
    // 静态类型构造器
    static MyClass()
    {
        // 这样定义只能处理枚举类型的泛型类型
        // CLR提供了约束的功能, 可以更好的指定有效的类型实参,
        // 但是约束无法将类型实参限制为仅枚举类型. 由于这个原因,
        // 所以需要用静态构构造器来保证类型是一个枚举类型
        if (!typeof(T).IsEnum)
        {
            throw new ArgumentException("T must be an Enum ");
        }
    }
    // 实例构造器
    public MyClass()
    {
    }
}

static void Main(string[] args)
{
    // 传入构造函数需要的参数
    Node<Char> head = new Node<Char>('C');
    head = new Node<char>('B',head);
    head = new Node<char>('A',head);
    Console.WriteLine(head.ToString());// 输出ABC
}
// 链表节点类
internal sealed class Node<T>
{
    public T m_data;
    public Node<T>  m_next;

    public Node(T mData, Node<T> mNext)
    {
        m_data = mData;
        m_next = mNext;
    }
    // 单参数构造函数,会通过this指针调用Node(T mData, Node<T> mNext)构造函数
    public Node(T mData) : this(mData,null)
    {
    }
    public override string ToString()
    {
        return m_data.ToString() + ((m_next != null) ? m_next.ToString() : String.Empty);
    }
}

static void Main(string[] args)
{
    // 传入构造函数需要的参数
    Node head = new TypeNode<Char>('.');
    head = new TypeNode<DateTime>(DateTime.Now,head);
    head = new TypeNode<String>("Today is ",head);
    Console.WriteLine(head.ToString());// Today is 2019/8/5 18:06:43.
}

// 非泛型Node基类
internal class Node
{
    protected Node m_next;

    public Node(Node mNext)
    {
        m_next = mNext;
    }
}

// 链表节点类
internal sealed class TypeNode<T> : Node
{
    public T m_data;

    // 基类没有无参构造函数,派生类要显式调用基类的
    public TypeNode(T mData, Node mNext) : base(mNext)
    {
        m_data = mData;
    }
    // 使用单个参数构造函数用this调用TypeNode(T mData, Node mNext),
    public TypeNode(T mData) : this(mData,null)
    {
    }
    public override string ToString()
    {
        return m_data.ToString() + ((m_next != null) ? m_next.ToString() : String.Empty);
    }
}

// 因为源代码中大量<>符号有损可读性
List<DateTime> dt1 = new ListList<DateTime>();

// 定义个新的非泛型类,从泛型类型派生
// 这样就只是为了简化代码没有了<>符号
internal sealed class DateTimeList : List<DateTime>
{
  //这里不用写任何代码
}

// false
Boolean sameType = (typeof(List<DateTime>) == typeof(DateTimeList));

// 用using指令定义DateTimeList符号.
// 代码编译时, 所有DateTimeList替换成System.Collections.Generic.List<System.DateTime>
using DateTimeList = System.Collections.Generic.List<System.DateTime>;

// true
Boolean sameType = (typeof(List<DateTime>) == typeof(DateTimeList));

// 还可以用var
var dt1 =new List<DateTime>();

// 这个泛型接口定义是FCL的一部分
public interface IEnumerator<T> : IDisposable, IEnumerator
{
  // 实现接口的需要有此属性
  T Current {get {...}}
}
// 实现了泛型接口, 保持类型实参的未指定状态
internal sealed class ArrayEnumrator<T> : IEnumerator<T>
{
  private T[] m_array;
  // IEnumerator<T>的Current是T类型.
  public T Current { get { ... }  }
}

// 委托定义
// in T 逆变量, out TResult协变量
public delegate TResult Func<in T, out TResult>(T arg);

// 如果像这样声明一个变量
Func<Object, ArgumentException> fn1 = null;
//    子类       基类
//     ↓          ↓
// 可以转型为另一个泛型类型参数不同的Func类型
Func<String, Exception> fn2 = fn1; // 不需要显式转型
Exception e = fn2("");

// 不能再调用它时传递List<Datetime>
// 虽然Datetime派生自Object
// 但是Datetime值类型和Object之间不存在引用转换
// 此外, 此方法最大的好处,JIT编译得到的代码只有一个版本
void Test(IEnumerable<Object> collection) { ... }

// 为了解决上面问题,可以这样声明
// 这样写,只有在T类型是引用类型的前提下,才能共享同一个版本的JIT编译代码
// 每个值类型都有一份不同的JIT编译代码
// 起码能传递值类型
void Test<T>(IEnumerable<T> collection) { ... }

// 编译不通过, 无效的可变性,T 必须是不变量, 当前T为逆变.
// delegate void SomeDelegate<in T>(ref T t);

// T可接受
public interface IEnumerator<in T> : IEnumerator
{
  Boolean MoveNext();
  T Current{ get; }
}

// 定义一个方法,接受任意引用类型的一个IEnumerator
Int32 Count(IEnumerator<Object> col) { ... }

// 以下调用Count,传递IEnumerator<String>
// 因为T是逆变量,String是Object的子类,所以编译没问题,可以顺利运行
Int32 c = Count(new[] {"Grant"});

static void Main(string[] args)
{

    GenericType<String> gt = new GenericType<string>("123");
    // 123 : System.Int32
    Console.WriteLine($"{gt.Converter<Int32>()} : {gt.Converter<Int32>().GetType()}");

}

// 定义了类型参数T
internal sealed class GenericType<T>
{
    private T m_value;

    public GenericType(T mValue)
    {
        m_value = mValue;
    }
    // 定义了自己的类型参数TOutput
    // Converter方法能将m_value字段引用的对象转换成任意类型(TOutput).取决于调用时传递的TOutput参数
    public TOutput Converter<TOutput>()
    {
        TOutput result = (TOutput) Convert.ChangeType(m_value, typeof(TOutput));
        // 返回类型转换之后的结果
        return result;
    }
}

// ref关键字标记参数,o1,o2必须先初始化,方法内能读写
// out关键字标记 则不必需初始化,不能读取,在返回前必须写入
private static void Swap<T>(ref T o1, ref T o2)
{
    T temp = o1;
    o1 = o2;
    o2 = o1;
}

// 这样调用Swap
Int32 n1 = 1, n2 = 2l;
Swap<Int32>(ref n1,ref n2);

private static vod Test()
{
  Int32 n1 = 1, n2 = 2;
  // 编译器会推断n1,n2的类型,最后调用Swap<Int32>
  Swap(ref n1, ref n2);

  // 重要说明: C#使用的是变量的数据类型, 而不是变量引用对象的实际类型
  String s1 = "A";
  Object s2 = "B";
  // 编译出错, 因为编译器无法推断用哪个传递的类型
  // 编译器发现s1是String , s2是Object(不是String )
  Swap(ref s1, ref s2);
}

private static void Display(String s)
{
  Console.WriteLine(s);
}
private static void Display<T>(T t)
{
  // 调用Display(String)
  Display(t.ToString());
}

// 调用的方式
// 2个方法都可以被调用,
// 但是C#编译器优先考虑明确的匹配, 再考虑泛型匹配
Display("Jeff");    // 调用Display(String)
Display(123);       // 调用Display<T>(T)
// 明确指定了泛型类型实参,告诉编译器不要尝试推断类型实参
// 所以编译器会毫不犹豫的代用泛型方法
Display<String>("AAA"); // 调用Display<T>(T)

private static T Min<T>(T o1,T o2)
{
  // 编译错误, 因为不是所有类型都能有ComparableTo方法
  //if (o1.ComparableTo(o2))
  {
    return o1;
  }
  return o2;
}

// 通过限制类型, 可以对那些类型进行更多的操作
// where关键字告诉编译器,为T指定的任何类型都必须实现IComparable<T>接口
private static T Min<T>(T o1,T o2) where T : IComparable<T>
{
  if (o1.ComparableTo(o2))
  {
    return o1;
  }
  return o2;
}

internal sealed class Test<T>{}

// 错误与Test<T>{}类定义冲突
//internal sealed class Test<T> where T : IComparable<T>{}

private static void M<T>();

// 错误与M<T>方法定义冲突
// private static void M<T> where T : IComparable<T>();

internal sealed class Test<T> where T : class
{
  public void M()
  {
    // 引用类型的变量都能设为null
    // 值类型的变量不能设置为null
    T temp = null; //允许,因为T约束为引用类型
  }
}

internal sealed class Test<T> where T : struct
{
  public static T Factory()
  {
    // 允许,因为所有值类型都隐式有一个公共无参构造器
    // 如果约束为class, 无法通过编译,因为有的引用类型没有公共的无参构造器.
    return new T();
  }
}

// 指定了两个类型参数
// T参数 由TBase类型参数约束, T必须兼容于TBase指定的类实参
private static List<TBase> ConvertIList<T, TBase>(IList<T> list) where T : TBase
{
    List<TBase> baseList = new List<TBase>(list.Count);

    for (int index = 0; index < list.Count; index++)
    {
        baseList.Add(list[index]);
    }
    return baseList;
}
static void Main(string[] args)
{
    // 初始化一个List<String> , 它实现了IList<String>
    List<String> ls = new List<string>();
    ls.Add("A String");

    // 将IList<String>转成IList<Object>
    // 编译器检查String是否兼容于Object,由于是派生关系,所以满足约束 T(string) : TBase(Object)
    IList<Object> lo = ConvertIList<String, Object>(ls);

    // 将IList<String> 转成IList<IComparable>
    // 编译器检查Strings是否实现了IComparable接口,由于String实现了,所以也满足约束.
    IList<IComparable> lc = ConvertIList<String, IComparable>(ls);

    // 将IList<String> 转成IList<IComparable<String>>
    // 由于String实现了接口,所以也满足约束.
    IList<IComparable<String>> lcs = ConvertIList<String, IComparable<String>>(ls);

    //  IList<String>转成 IList<String>
    IList<String> ls2 = ConvertIList<String, String>(ls);

    // 错误,不能将IList<String>转 IList<Exception>
    // String没有隐式引用转换到Exception
    // IList<Exception> le = ConvertIList<String, Exception>(ls);
}

internal sealed class Test<T> where T : new()
{
  public static T Factory()
  {
    // 允许,因为所有值类型都隐式有一个公共无参构造器
    // 如果约束为class, 约束也要求它提供公共无参构造器
    return new T();
  }
}

// 尝试写一个能处理任何数据类型的算法
private static T Sum<T>(T num) where T : struct
{
    T sum = default(T);
    // 报错. 运算符< ++ += 无法应用于"T"和"T"类型的操作数
    for (T n = default(T); n < num; n++)
    {
        // 报错. 运算符< ++ += 无法应用于"T"和"T"类型的操作数
        sum += n;
    }
    return sum;
}