C# 泛型

        /// <summary>
        /// 泛型方法：方法名称后面加上尖括号，里面是类型参数
        /// 类型参数实际上就是一个类型T声明，方法就可以用这个类型T了
        ///           
        /// 思考下，泛型为什么也可以，支持多种不同类型的参数？
        /// 泛型声明方法时，并没有写死类型，T是什么，不知道
        /// T要等着调用的时候才指定
       
        /// 正是因为没有写死，才拥有了无限的可能！！
        /// 
        /// 设计思想--延迟声明：推迟一切可以推迟的，一切能晚点再做的事儿，就晚点再做
        /// 深入一下，泛型的原理
        /// 
        /// 泛型在代码编译时，究竟生成了一个什么东西
        /// 泛型不是一个简单的语法糖，是框架升级支持的
        /// 
        /// 泛型方法的性能跟普通方法一致，是最好的，
        /// 而且还能一个方法满足多个不同类型
        /// 又叫马儿跑，又叫马儿不吃草，是因为框架的升级支持的！！
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tParameter"></param>
        public static void Show<T>(T tParameter)//, T t = default(T
        {
            Console.WriteLine("This is {0},parameter={1},type={2}",
               typeof(CommonMethod), tParameter.GetType().Name, tParameter);
        }

        //WebServices WCF 都不能用泛型，为什么？
        //跨语言的，别的语言也能用，不支持泛型。。
        //服务在发布的时候是必须确定的，泛型在编译时确定不了

    public interface GenericInterface<T>
    {
    }

    public class GenericClass<T> 
    {
    }

public delegate T DoSomething<T>();

        /// <summary>
        /// 没有约束，其实很受局限
        /// where T:BaseModel
        /// 基类约束：
        /// 1 可以把T当成基类---权利
        /// 2 T必须是基类或者其子类
        ///为什么要有约束？  因为有约束才有权利
        ///自由主义的鼻祖洛克先生说过，有了法律，才有自由
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tParameter"></param>
        public static void Show<T>(T tParameter)
            //where T : String//密封类约束的不行，因为没有意义
            //where T : People
            //where T : ISports
            where T : People, ISports, IWork, new()

        {
            Console.WriteLine("This is {0},parameter={1},type={2}",
               typeof(GenericConstraint), tParameter.GetType().Name, tParameter);

            Console.WriteLine($"{tParameter.Id}  {tParameter.Name}");
            tParameter.Hi();
            //tParameter.Pingpang();
        }
       public T GetT<T, S>()
            //where T : class//引用类型约束
            //where T : struct//值类型
            where T : new()//无参数构造函数
            where S : class
        {
            //return null;
            //return default(T);//default是个关键字，会根据T的类型去获得一个默认值
            return new T();
            //throw new Exception();
        }