泛型

generic：

为什么要有泛型？

　　不需要对每一种类型定义相同的功能方法，实现代码的重用性

　　提高性能和类型安全性

真是理解泛型T

　　理解T为一个类型占位符

泛型种类：

　　根据泛型类型参数是否提供分为：

　　　　1.未绑定的泛型类型

　　　　2.已构造泛型

　　已构造泛型又可以分为:

　　　　开放型泛型类型：List<>

　　　　和封闭泛型类型:list<string>,List<int>

泛型中的静态字段和静态函数问题

　　对于一个普通类MyClass来说定义了静态字段x不管之后创建了多少个类的实例只存在一个MyClass.x

　　但是泛型类型并非如此。每个封闭的泛型类型都有数据他自己的静态数据

 class Program
    {
        static void Main(string[] args)
        {
            TypeWithStaticField<string>.field="一";
            TypeWithStaticField<int>.field = "二";
            TypeWithStaticField<Guid>.field = "三";
            TypeWithStaticField<string>.field = "si";
            NoGenericStaticField.field = "非泛型字段1";
            NoGenericStaticField.field = "非泛型字段2";
            NoGenericStaticField.field = "非泛型字段3";
            NoGenericStaticField.OutField();

            TypeWithStaticField<string>.OutField();
            TypeWithStaticField<int>.OutField();
            TypeWithStaticField<Guid>.OutField();
            Console.ReadKey();
            Console.WriteLine("Hello World!");
        }
    }

    /// <summary>
    /// 泛型类型 
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public static class TypeWithStaticField<T>
    {
        public static string field;

        public static void OutField()
        {
            Console.WriteLine(field+":"+typeof(T));
        }
    }


    public static class NoGenericStaticField
    {
        public static string field;

        public static void OutField()
        {
            Console.WriteLine(field  );
        }
    }

对于编译器来说，每个封闭的泛型类型都是一种不一样的类型，所以他们都有属于自己的静态字段。

对于静态的构造函数也是如此

class Program
    {
        static void Main(string[] args)
        {
            GenericClass<int>.Print();
            GenericClass<string>.Print();
            NoGenericClass.Print();
            NoGenericClass.Print();

            Console.ReadKey();
        }
    }


    public static class GenericClass<T>
    {
        static GenericClass()
        {
            Console.WriteLine("泛型的静态函数被调用了，实际类型为T:" + typeof(T));
        }



        public static void Print()
        {

        }
    }

    public static class NoGenericClass
    {
        static NoGenericClass()
        {
            Console.WriteLine("非泛型的静态函数被调用了，实际类型为GenericClass");
        }



        public static void Print()
        {

        }
    }

静态泛型类的构造函数被调用多次

静态非泛型类被调用多次

类型推断：

static void Main(string[] args)
        {
          
            int num1 = 101;
            int num2 = 102;
            // 使用类型推断代码
            GenericMethod<int>(ref num1, ref num2);
            Console.ReadKey();
        }

        private static void GenericMethod<T>(ref T t1,ref T t2)
        {
            T temp = t1;
            t1 = t2;
            t2 = t1;
        }

类型推断只能使用方法，不能适用于泛型类，因为编译器不同通过泛型类的构造方法推断出实际参数

泛型类的约束：