C#学习笔记（五）：泛型

认识泛型

泛型使类型参数化，从而实现了算法上的代码重用。

同时由于去掉了转换中装箱和拆箱的操作，使用泛型还可以提高程序的运行速度。

我们先看看C#自带的使用了泛型的类：

using System.Collections.Generic;

namespace Study
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> list1 = new List<int>();
            list1.Add(100);
            int i = list1[0];

            List<string> list2 = new List<string>();
            list2.Add("Hello");
            string s = list2[0];
        }
    }
}

通过使用泛型，我们可以重复利用List提供的功能，而不用每个类型对应去写一个List的类。

泛型在类上的实现

下面我们自己使用泛型编写一个简单的类，如下：

using System;

namespace Study
{
    class Program
    {
        static void Main(string[] args)
        {
            Test<int> test1 = new Test<int>();
            test1.myValue = 100;
            Console.WriteLine(test1.myValue);

            Test<string> test2 = new Test<string>();
            test2.myValue = "Hello";
            Console.WriteLine(test2.myValue);
        }
    }

    public class Test<T>
    {
        private T _myValue;

        public T myValue
        {
            set { _myValue = value; }
            get { return _myValue; }
        }
    }
}

Test类中的尖括号里面的T即为泛型，其可以表示任意的类型。

泛型约束

我们上面示例中的T可以使用任意的类型，那么如果我们只希望T是某类型或某类型的子类该怎么办呢？

public class Test<T> where T : IComparable

如果这样写，则表示T必须是实现了IComparable接口的对象。

多个类型的情况

多个类型的写法如下：

public class Test<T, K> where T : IComparable where K : ICloneable

如上所示，一个类型如果要添加约束就需要写一个where进行对应，所以有多个就会有多个where关键字出现。

创建类型的情况

如果需要使用new创建一个类型，则需要在约束里添加new()的字符串，如下：

using System;

namespace Study
{
    class Program
    {
        static void Main(string[] args)
        {
            Test<Data> test1 = new Test<Data>();
            Console.WriteLine(test1.myComparable.s);

            Console.Read();
        }
    }

    public class Test<T> where T : IComparable, new()
    {
        private T _myComparable;

        public T myComparable
        {
            set { _myComparable = value; }
            get { return _myComparable; }
        }

        public Test()
        {
            _myComparable = new T();
        }
    }

    public class Data : IComparable
    {
        public string s = "Hello World!";

        public int CompareTo(object obj)
        {
            return 0;
        }
    }
}

但是如果是值类型，则不需要这么写，但是要约束T为值类型，如下：

using System;

namespace Study
{
    class Program
    {
        static void Main(string[] args)
        {
            Test<int> test1 = new Test<int>();
            Console.WriteLine(test1.myComparable);

            Console.Read();
        }
    }

    public class Test<T> where T : struct
    {
        private T _myComparable;

        public T myComparable
        {
            set { _myComparable = value; }
            get { return _myComparable; }
        }

        public Test()
        {
            _myComparable = new T();
        }
    }
}

default关键字

当我们需要对泛型T置空时不能直接写“xxx=null;”因为只有当 T 为引用类型时，语句 t = null 才有效；只有当 T 为数值类型而不是结构时，语句 t = 0 才能正常使用。所以我们使用default关键字就可以解决这个问题，如下：

_myComparable = default(T);

泛型继承

子类也有相同的泛型时：

public class A<T>
{ }

public class B<T> : A<T>
{ }

当然，你可以使用另外的名称，只要能对应上即可：

public class A<T>
{ }

public class B<K> : A<K>
{ }

子类指定好类型：

public class A<T>
{ }

public class B : A<string>
{ }

子类添加新类型：

public class A<T>
{ }

public class B<T, K> : A<T>
{ }

泛型在方法上的实现

如果要在方法上添加类上没有指定的类型，可以直接在方法上添加泛型：

using System;

namespace Study
{
    class Program
    {
        static void Main(string[] args)
        {
            Test<int> test = new Test<int>();
            Console.WriteLine(test.Func<string>("Hello"));

            Console.Read();
        }
    }

    public class Test<T>
    {
        public K Func<K>(K k)
        {
            return k;
        }
    }
}

泛型在委托上的实现

委托上也可以使用泛型，定义方法和在方法上使用泛型一致，如下：

using System;

namespace Study
{
    class Program
    {
        static void Main(string[] args)
        {
            new Test();

            Console.Read();
        }
    }

    public class Test
    {
        public delegate T add<T>(T a, T b);

        public Test()
        {
            add<int> func1 = AddInt;
            Console.WriteLine(func1(100, 23));

            add<float> func2 = AddFloat;
            Console.WriteLine(func2(1.2f, 0.03f));
        }

        private int AddInt(int a, int b)
        {
            return a + b;
        }

        private float AddFloat(float a, float b)
        {
            return a + b;
        }
    }
}

泛型接口

泛型接口的使用和泛型类一致，大家可以查看微软自己的文档：https://msdn.microsoft.com/zh-cn/library/kwtft8ak(VS.80).aspx

泛型和静态字段与方法

泛型同样可以使用在静态字段和方法中，由于静态字段和方法在内存中始终只存在一个，所以当我们使用了泛型的时候，编译器会帮我们自动生成对应的方法。

泛型静态的使用和动态一致就跳过不说了。

类型推断

我们在调用泛型方法时可以省略泛型类型的书写，完全交由编译器根据我们的类型来进行判断，这样可以减小代码量同时也更清晰：

using System;

namespace Study
{
    class Program
    {
        static void Main(string[] args)
        {
            //没有类型推断
            Console.WriteLine(CompareTo<int>(100, 100));

            //使用类型推断
            Console.WriteLine(CompareTo(12.3f, 12.33f));
            Console.WriteLine(CompareTo('a', 'a'));

            Console.Read();
        }

        private static int CompareTo<T>(T a, T b) where T : IComparable
        {
            return a.CompareTo(b);
        }
    }
}

泛型的可变性

我们先看一个例子：

using System;
using System.Collections.Generic;

namespace Study
{
    class Program
    {
        static void Main(string[] args)
        {
            List<B> listB = new List<B>();

            //下面这句代码会报错
            //Cannot convert source type 'System.Collections.Generic.List<Study.B>' to 
            //target type 'System.Collections.Generic.List<Study.A>'
            List<A> listA = listB;

            Console.Read();
        }
    }

    public class A
    {}

    public class B : A
    {}
}

我们发现虽然B继承于A，但是List<A>和List<B>之间是不能相互转换的。

为了解决这个问题，微软在C#4.0中添加了对泛型的可变性的支持。

协变性

协变性指的是泛型类型参数可以从一个派生类隐式地转换为其基类。

out关键字

协变使用out关键字标识，如下：

public interface MyInterface<out T>

示例：

using System;
using System.Collections.Generic;

namespace Study
{
    class Program
    {
        static void Main(string[] args)
        {
            MyInterface<B> myB = new MyClass<B>();
            MyInterface<A> myA = myB;

            Console.Read();
        }
    }

    public interface MyInterface<out T>
    {}

    public class MyClass<T> : MyInterface<T>
    {}

    public class A
    {}

    public class B : A
    {}
}

逆变性

逆变性指的是泛型类型参数可以从一个基类隐式的转换为其派生类。

in关键字

public interface MyInterface<in T>

示例：

using System;
using System.Collections.Generic;

namespace Study
{
    class Program
    {
        static void Main(string[] args)
        {
            MyInterface<A> myA = new MyClass<A>();
            MyInterface<B> myB = myA;

            Console.Read();
        }
    }

    public interface MyInterface<in T>
    {}

    public class MyClass<T> : MyInterface<T>
    {}

    public class A
    {}

    public class B : A
    {}
}

注意事项

1. 只有接口和委托支持协变和逆变，类或方法都不支持协变和逆变；
2. 协变和逆变只支持引用类型，值类型不支持协变和逆变；
3. 必须显示的使用out或in来标记协变和逆变；
4. 委托的协变和逆变不要在多播委托中使用；
5. 协变和逆变不能同时使用，只能选择一种；