C#泛型

1. 泛型方法：一个方法满足不同类型，做同样的事

泛型与object的区别：

当类性为object的时候：

        /// <summary>
        /// 打印个object值
        /// 1 object类型是一切类型的父类
        /// 2 通过继承，子类拥有父类的一切属性和行为；任何父类出现的地方，都可以用子类来代替/// 
        /// object引用类型  加入传个值类型int  会有装箱拆箱  性能损失
　　　　　/// 装箱拆箱： 装箱==>栈--堆   值类型在栈内存中，引用类型在堆内存中
　　　　  /// 拆箱： ==> 堆-->栈

        /// 类型不安全
        /// </summary>
        /// <param name="oParameter"></param>
        public static void ShowObject(object oParameter)
        {
            Console.WriteLine("This is {0},parameter={1},type={2}",
                typeof(CommonMethod), oParameter.GetType().Name, oParameter);

            //Console.WriteLine($"{((People)oParameter).Id}_{((People)oParameter).Name}");
        }

泛型时：

        /// <summary>
        /// 2.0推出的新语法
        /// 泛型方法解决用一个方法，满足不同参数类型；做相同的事儿
        /// 没有写死参数类型，调用的时候才指定的类型
        /// 单身狗：小西瓜
        /// 章子怡  范冰冰  凤姐
        /// 延迟声明：把参数类型的声明推迟到调用
        /// 
        /// 推迟一切可以推迟的~~  延迟思想 ===》架构设计时思想===>提升性能  
        /// 举例： 网页加载数据在滚动到内容时菜加载数据等
        /// 
        /// 不是语法糖，而是2.0由框架升级提供的功能
        /// 需要编译器支持+JIT支持
        /// </summary>
        /// <typeparam name="T">T/S 不要用关键字  也不要跟别的类型冲突 </typeparam>
        /// <param name="tParameter"></param>
        public static void Show<T>(T tParameter)
        {
            Console.WriteLine("This is {0},parameter={1},type={2}",
                typeof(GenericMethod), tParameter.GetType().Name, tParameter.ToString());
        }

dynamic：  动态类型：运行时不知道它是什么类型

var：语法糖，自动识别类型

2. 泛型类、泛型接口、委托

/// <summary>
/// 一个类来满足不同的具体类型，做相同的事儿
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="S"></typeparam>
/// <typeparam name="X"></typeparam>
/// <typeparam name="Eleven"></typeparam>
/// <typeparam name="老K"></typeparam>
public class GenericClass<T>
//, S, X, Eleven, 老K>
//where T : People
//where S : Chinese
//where Eleven : Hubei
{
public T _T;
}

/// <summary>
/// 一个接口来满足不同的具体类型的接口，做相同的事儿
/// </summary>
/// <typeparam name="T"></typeparam>
public interface IGenericInterface<T> //where T : People
{
T GetT(T t);//泛型类型的返回值
}

public class CommonClass
//: GenericClass<int>//必须指定
: IGenericInterface<int>//必须指定
{
public int GetT(int t)
{
throw new NotImplementedException();
}
}

public class GenericClassChild<Eleven>
//: GenericClass<Eleven>
: GenericClass<int>, IGenericInterface<Eleven>
{
public Eleven GetT(Eleven t)
{
throw new NotImplementedException();
}
}

public delegate void SayHi<T>(T t);//泛型委托

3.泛型约束

   public class Constraint
    {
        /// <summary>
        /// 泛型：不同的参数类型都能进来；任何类型都能过来，你知道我是谁?
        /// 没有约束，也就没有自由
        /// 泛型约束--基类约束（不能是sealed）：
        /// 1 可以使用基类的一切属性方法---权利
        /// 2  强制保证T一定是People或者People的子类---义务
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tParameter"></param>
        public static void Show<T>(T tParameter)
            where T : People, ISports, IWork, new()
        {
            //Console.WriteLine("This is {0},parameter={1},type={2}",
            //    typeof(GenericMethod), tParameter.GetType().Name, tParameter.ToString());

            Console.WriteLine($"{tParameter.Id}_{tParameter.Name}");
            tParameter.Hi();
            //tParameter.Majiang();
            tParameter.Pingpang();
            tParameter.Work();
        }
        public static void ShowBase(People tParameter)//因为约束可以叠加  更灵活
        {
            Console.WriteLine($"{tParameter.Id}_{tParameter.Name}");
            tParameter.Hi();
        }


        //为啥不直接用基类
        //int？

        public static T Get<T>(T t)
            //where T : ISports//接口约束
            //where T : class//引用类型约束
            //where T : struct//值类型约束
            where T : new()//无参数构造函数约束
        {
            //t.Pingpang();
            //T tNew = null;
            //T tNew = default(T);//会根据T的不同  赋予默认值
            T tNew = new T();
            return t;
        }
    }

    public interface ISports
    {
        void Pingpang();
    }

    public interface IWork
    {
        void Work();
    }


    public class People
    {
        public int Id { get; set; }
        public string Name { get; set; }

        public void Hi()
        {
            Console.WriteLine("Hi");
        }

    }

    public class Chinese : People, ISports, IWork
    {
        public void Tradition()
        {
            Console.WriteLine("仁义礼智信，温良恭俭让");
        }
        public void SayHi()
        {
            Console.WriteLine("吃了么？");
        }

        public void Pingpang()
        {
            Console.WriteLine("打乒乓球...");
        }

        public void Work()
        {
            throw new NotImplementedException();
        }
    }

    public class Hubei : Chinese
    {
        public Hubei(int version)
        { }

        public string Changjiang { get; set; }
        public void Majiang()
        {
            Console.WriteLine("打麻将啦。。");
        }
    }


    public class Japanese : ISports
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public void Hi()
        {
            Console.WriteLine("Hi");
        }


        public void Pingpang()
        {
            Console.WriteLine("打乒乓球...");
        }
    }