笔记：CLR var C# 第12章

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace ClrVarCSharp.C12Generic
{
    class Program
    {
        public static void Main(string[] args)
        {
            //A.Test1();
            //B.Test2();
            //C.Test2();
            //Test3();
            //Test4();
            //Test5();

        }

        //12.2.1 开放类型和封闭类型
        public sealed class DictionaryStringKey<TValue> : Dictionary<string, TValue> { }
        public static class A
        {
            public static void Test1()
            {
                object o = null;

                Type t = typeof(Dictionary<,>);
                o = CreateInstance(t);  //创建开放类型实例失败
                Console.WriteLine();

                t = typeof(DictionaryStringKey<>);  //开放类型
                o = CreateInstance(t);
                Console.WriteLine();

                t = typeof(DictionaryStringKey<Guid>);
                o = CreateInstance(t);
                Console.WriteLine(o.GetType());

            }

            private static object CreateInstance(Type t)
            {
                object o = null;
                try
                {
                    o = Activator.CreateInstance(t);
                    Console.WriteLine("已创建 {0} 的实例。", t.ToString());
                }
                catch (ArgumentException e)
                {
                    Console.WriteLine(e.Message);
                }
                return o;
            }
        }

        //12.2.2 泛型类型和继承
        //该链表只能接受一种类型
        class B
        {
            sealed class Node<T>
            {
                public T m_data;
                public Node<T> m_next;
                public Node(T data) : this(data, null)
                {

                }
                public Node(T data, Node<T> next)
                {
                    m_data = data;
                    m_next = next;
                }
                public override string ToString()
                {
                    return m_data.ToString() +
                        ((m_next != null) ? m_next.ToString() : string.Empty);
                }
            }
            public static void Test2()
            {
                Node<char> head = new Node<char>('C');
                head = new Node<char>('B', head);
                head = new Node<char>('A', head);
                Console.WriteLine(head.ToString());
            }
        }
        //该链表可接受不同的类型
        class C
        {
            class Node
            {
                protected Node m_next;
                public Node(Node next)
                {
                    m_next = next;
                }
            }
            sealed class TypeNode<T> : Node
            {
                public T m_data;
                public TypeNode(T data) : this(data, null)
                {

                }
                public TypeNode(T data, Node next) : base(next)
                {
                    m_data = data;
                }
                public override string ToString()
                {
                    return m_data.ToString() +
                        ((m_next != null) ? m_next.ToString() : string.Empty);
                }
            }
            public static void Test2()
            {
                Node head = new TypeNode<char>('.');
                head = new TypeNode<DateTime>(DateTime.Now, head);
                head = new TypeNode<string>("Today is ", head);
                Console.WriteLine(head.ToString());
            }
        }

        //12.2.3 泛型类型同一性
        List<DateTime> dt1 = new List<DateTime>();
        internal sealed class DateTimeList : List<DateTime> { /* 内部无需任何代码 */ }  //DateTimeList与DateTime是两个不同的类型
        //using DateTimeList = System.Collections.Generic.List<System.DateTime>;  //简化代码又保证是同一类型
        static void Test3()
        {
            DateTimeList dt2 = new DateTimeList();  //通过以上定义，简化了<>
            bool sameType = (typeof(List<DateTime>) == typeof(DateTimeList));
            Console.WriteLine(sameType);
        }

        //12.6 泛型方法
        sealed class GenericType<T>
        {
            private T m_value;
            public GenericType(T value) { m_value = value; }
            public TOutput Converter<TOutput>()
            {
                TOutput result = (TOutput)Convert.ChangeType(m_value, typeof(TOutput));
                return result;
            }
        }

        private static void Swap<T>(ref T o1, ref T o2)
        {
            T temp = o1;
            o1 = o2;
            o2 = temp;
        }

        //12.8 可验证性和约束
        public static T Min<T>(T o1, T o2) where T : IComparable<T>
        {
            if (o1.CompareTo(o2) < 0)
                return o1;
            return o2;
        }

        static void Test4()
        {
            object o1 = "X2009";
            object o2 = "abc";
            //object oMin = Min<object>(o1, o2);  //编译错误
        }

        //泛型类型/方法重载
        //只能定义基于参数数量的重载
        sealed class AType { }
        sealed class AType<T> { }
        sealed class AType<T1, T2> { }
        //不能定义仅基于约束的重载
        //sealed class AType<T> where T : IComparable<T> { }
        //不能定义基于名称的重载
        //sealed class AType<T3, T4> { }

        //12.8.1 主要约束，约束为非密封类的一个引用类型
        sealed class PrimaryConstraintOfStream<T> where T : Stream
        {
            public void M(T stream)
            {
                stream.Close();
            }
        }
        //12.8.2 次要约束，约束为接口类型

        //用一个泛型来约束另一个泛型：指定参数是约束类型或其派生类型
        static List<T2> ConvertIList<T1, T2>(IList<T1> list) where T1 : T2
        {
            List<T2> baseList = new List<T2>(list.Count);
            for (int index = 0; index < list.Count; index++)
            {
                baseList.Add(list[index]);
            }
            return baseList;
        }

        static void Test5()
        {
            IList<string> ls = new List<string>();
            ls.Add("A String");

            //IList<string>转换为IList<object>
            IList<object> lo = ConvertIList<string, object>(ls);

            IList<IComparable> lc = ConvertIList<string, IComparable>(ls);

            IList<IComparable<string>> lcs = ConvertIList<string, IComparable<string>>(ls);

            IList<string> ls2 = ConvertIList<string, string>(ls);

            //IList<Exception> le = ConvertIList<string, Exception>(ls);
        }

        //12.8.3 构造器约束
        sealed class ConstructorConstraint<T> where T : new()
        {
            public static T Factory()
            {
                return new T();
            }
        }

        //12.8.4 其他可验证性问题
       //1). 泛型的类型转换
        static void Test6<T>(T obj)
        {
            //编译错误
            //int x = (int)obj;
            //string s = (string)obj;
        }

        static void Test7<T>(T obj)
        {
            //可通过编译，但可能出现运行时异常
            int x = (int)(object)obj;
            string s = (string)(object)obj;
        }

        static void Test8<T>(T obj)
        {
            //无错误
            string s = obj as string;
        }

        //2). 泛型初始化
        static void Test9<T>()
        {
            //T temp = null;
            T temp = default(T);
        }
        
    }
}