泛型

一、引言

前面我们学过泛型集合List,非泛型集合ArrayList，了解到创建List集合的时候，需要指定类型，并且只能存储这种类型的数据，相比ArrayList能存储各种类型的数据而言，效率更高（避免了装箱拆箱）。那我们声明List<int>集合的时候，开始为何不直接设计一个ListInt类，而要设计成List<T>呢？因为List中的方法，算法其实是一样的，这样可以避免重复，并且，如果我要在List中保存自己自定义的类的对象的时候，（比如Person）,无法再像开始那样，有预见性的设计出一个ListPerson类。所以需要引入泛型。

二、泛型类

下面看一个具体的例子：

public class MyClass
    {
        public string [] Names { get; set; }

        public MyClass(string [] names)
        {
            this.Names = names;
        }

        public void Show()
        {
            foreach (string item in Names)
            {
                Console.WriteLine(item);
            }
        }
    }

在控制台程序中输出数组中的元素：

static void Main(string[] args)
        {

            string[] names = { "A","B","C","D"};

            MyClass mc = new MyClass(names);
            mc.Show();

            Console.ReadKey();
        }

现在需求改动，想把string类型的数组改成int类型的，这时候，我们只好把MyClass中和控制台中所有关于类型的地方全部改下，但是其他地方丝毫不用改。这当然可以，只是有点麻烦，有没有其他方式，不用改动MyClass中的东西呢？

这时候可以泛型。改动后的代码如下：

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

            string[] names = { "A","B","C","D"};
            //MyClass<string> mc = new MyClass<string>(names);

            //如果要改成Int类型的数组，只要作如下改动
            MyClass<int> mc = new MyClass<int>(new int[] {1,2,3,4 });
            
            mc.Show();

            Console.ReadKey();
        }
    }

    public class MyClass<T>
    {
        public T [] Names { get; set; }

        public MyClass(T [] names)
        {
            this.Names = names;
        }

        public void Show()
        {
            foreach (T item in Names)
            {
                Console.WriteLine(item);
            }
        }
    }

这里我们能明显看到泛型的方便了。

三、泛型接口

 有以上的基础，看泛型接口就可以容易了，直接上代码：

 public interface IFlyable<T>
    {
        void Fly(T t);
    }

但是要注意：

1.如果是实例类实现泛型接口，泛型接口必须指定泛型的类型：

 public class SpiderMan : IFlyable<string>
    {
        public void Fly(string t)
        {
            Console.WriteLine(t);
        }
    }

2.如果是泛型类，实现泛型接口的时候必须指定泛型的类型：

public class SpiderMan<T> : IFlyable<T>
    {
        public void Fly(T t)
        {
            throw new NotImplementedException();
        }
    }

四、泛型方法

public class Person
    {
        //方法后面加个<T>就是泛型方法
        public void Show<T>(T t)
        {
            Console.WriteLine(t);
        }
    }

main函数中的代码：

  Person p = new Person();
            p.Show("aaa");//方法名称后面不加<T>，编译器会根据传入的数据，自动推断
            p.Show<string>("aaa");//
            p.Show(2);

五、泛型委托

 首先写几委托和方法：

public delegate void MDelegate(string str);

public delegate void IDelegate(int i);
    public delegate void MDelegate(string str);
    public delegate void DDelegate(double d);

方法：

static void M1(int i)
        {
            Console.WriteLine(i);
        }

        static void M2(string s)
        {
            Console.WriteLine(s);
        }

        static void M3(double d)
        {
            Console.WriteLine(d);
        }

我们要使用MDelegate这个委托只能传入方法签名一致的方法M2，如果我想调用M1，M3方法的话，必须再写两个委托，太麻烦。

MDelegate m = M2;
            m("124");

            IDelegate i = M1;
            i(1);

            DDelegate d = M3;
            d(1.2);

 但是改成泛型委托，情况就变得简单很多了

public delegate void DynamicDelegate<T>(T t);

用上面泛型委托，可以调用M1，M2，M3方法，如下：

DynamicDelegate<int> i = M1;
            i(1);

            DynamicDelegate<string> s = M2;
            s("afsd");

            DynamicDelegate<double> d = M3;
            d(1.2);