C#泛型.

泛型（Generic） 允许延迟编写类或方法中的编程元素的数据类型的规范，直到实际在程序中使用它的时候才确定数据类型。

泛型成员因类型不确定，可能是类、结构体、字符、枚举……所以不能使用算术运算符、比较运算符等进行运算！
注意，可以使用赋值运算符

泛型的优点:

        1.可以重用代码，保护数据类型安全和提高性能。

        2.如果使用多个数据类型可以使用泛型集合定义多个类，

 public static void TestMothod<T,W>(T a, W b) {
     Console.WriteLine(a.GetType().ToString());
     Console.WriteLine(b.GetType().ToString());
}

        3.可以使用泛型约束来访问特定数据类型的方法

where T : struct        //约束 T 必须是值类型  
where K : class         //约束 K 必须是引用类型 
where V : IClass<T>     //约束 V 必须继承  IClass<T> 接口
where W : className   //约束 W 必须是 className 类型，或者是 className 类型的子类 
where X : class, new()  //约束 X 必须是引用类型，并且有一个无参数的构造函数，当有多个约束时，new()必须写在最后

泛型示例:

internal class Program
    {
        static void Main(string[] args)
        {
            FanXing fanXing = new FanXing();
            int a = 10;
            fanXing.FanXingMothod(a);
            string b = "张三";
            fanXing.FanXingMothod(b);

            Console.ReadKey();
        }
    }
    public class FanXing
    {
        public void FanXingMothod<T>(T a)
        {
            Console.WriteLine($"泛型:{a}");
        }
    }

返回值可以是泛型: 

internal class Program
    {
        static void Main(string[] args)
        {
            
            int resultNumber = FanXingMothod<int>(100);

            Console.ReadKey();
        }

        public static T FanXingMothod<T>(T a)
        {
            Console.WriteLine(a);
            return a;

        }
    }

多个泛型：

internal class Program
    {
        static void Main(string[] args)
        {

            TestMothod<int, string>(300, "abc");

            Console.ReadKey();
        }

        public static void TestMothod<T, W>(T a, W b)
        {
            Console.WriteLine(a.GetType().ToString());
            Console.WriteLine(b.GetType().ToString());
            Console.WriteLine(a);
            Console.WriteLine(b);
        }
    }

泛型类:

internal class Program
    {
        static void Main(string[] args)
        {

            FanXingClass<int> fanXingClass = new FanXingClass<int>();
            fanXingClass.Age = 10;
            fanXingClass.Bge = 20;
            fanXingClass.FanXingMothod(300, 400);

            Console.ReadKey();
        }

    }
    //泛型类
    public class FanXingClass<T>
    {
        public T Age { get; set; }
        public T Bge { get; set; }
        public void FanXingMothod(T a, T b)
        {
            Console.WriteLine(a.GetType().ToString());
            Console.WriteLine(b.GetType().ToString());
            Console.WriteLine(a);
            Console.WriteLine(b);

        }
    }

internal class Program
    {
        static void Main(string[] args)
        {

            FanXingClass1<int, string> fan = new FanXingClass1<int, string>();
            fan.Age = 10;
            fan.Bge = 20;
            fan.Cge = "abc";
            fan.FanXingMothod1(10, "ABC");

            Console.ReadKey();
        }

    }
    //泛型类
    public class FanXingClass1<T, C>
    {
        public T Age { get; set; }
        public T Bge { get; set; }
        public C Cge { get; set; }
        public void FanXingMothod(T a, T b)
        {
            Console.WriteLine(a.GetType().ToString());
            Console.WriteLine(b.GetType().ToString());
            Console.WriteLine(a);
            Console.WriteLine(b);
        }
        public void FanXingMothod1(T a, C b)
        {
            Console.WriteLine(a.GetType().ToString());
            Console.WriteLine(b.GetType().ToString());
            Console.WriteLine(a);
            Console.WriteLine(b);
        }
    }

泛型约束: