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

认识泛型

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

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

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

 using System.Collections.Generic;

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

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

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

泛型在类上的实现

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

 using System;

 namespace Study
 {
     class Program
     {
         static void Main(string[] args)
         {
             Test<int> test1 = new Test<int>();
             test1.myValue = ;
             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 ;
         }
     }
 }

但是如果是值类型，则不需要这么写，但是要约束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(, ));

             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>(, ));

             //使用类型推断
             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. 协变和逆变不能同时使用，只能选择一种；