扫清C#泛型的迷障 - 从基础到实战

什么是泛型？

泛型（Generics）是C#的一种特性，它允许你在编写代码时，不指定具体的类型，而是使用类型参数作为占位符。这样一来，你的代码就可以对多种类型进行复用，增加了灵活性，同时还能保持类型安全。

简单来说，泛型就是一种“模板”，你可以用它来创建可重用、类型安全的代码。

为什么需要泛型？

在没有泛型之前，如果你想创建一个可以存储任意类型对象的集合，比如 ArrayList，你可能会这样做：

ArrayList list = new ArrayList();
list.Add(1);
list.Add("Hello");
list.Add(DateTime.Now);

这样虽然灵活，但有两个主要问题：

类型安全问题：从集合中取出元素时，需要进行类型转换，如果转换错误，会导致运行时异常。
性能问题：对于值类型（如int），在添加到集合时，需要进行装箱（Boxing）；取出时，需要拆箱（Unboxing），这会影响性能。

泛型的优势

类型安全：在编译时就能检查类型错误，避免运行时异常。
提高性能：避免了装箱和拆箱操作。
代码复用：可以编写更通用的代码，对多种类型适用。

使用泛型的示例

C#提供了很多泛型集合类型，比如List、Dictionary<TKey, TValue>等。

示例：使用List

List<int> numbers = new List<int>();
numbers.Add(1);
numbers.Add(2);
numbers.Add(3);foreach (int number in numbers)
{Console.WriteLine(number);
}

在这里，List表示一个存储整数的列表。由于指定了类型参数为int，所以列表中只能添加整数，编译器会帮你检查类型。

如何自定义泛型

接下来，我们看看如何自定义泛型类和泛型方法。

1. 自定义泛型类
示例：创建一个通用的存储盒子

public class Box<T>
{private T item;public void Put(T item){this.item = item;Console.WriteLine($"已将 {item} 放入盒子。");}public T Get(){Console.WriteLine($"从盒子中取出了 {item}。");return item;}
}

解释：

Box：T是类型参数，表示盒子可以存储任意类型的物品。
Put方法：用于将物品放入盒子。
Get方法：用于从盒子中取出物品。

使用泛型类：

// 创建一个存储整数的盒子
Box<int> intBox = new Box<int>();
intBox.Put(123);
int number = intBox.Get();
Console.WriteLine($"取出的数字是：{number}");// 创建一个存储字符串的盒子
Box<string> strBox = new Box<string>();
strBox.Put("Hello, 泛型！");
string message = strBox.Get();
Console.WriteLine($"取出的消息是：{message}");

输出：

已将 123 放入盒子。
从盒子中取出了 123。
取出的数字是：123
已将 Hello, 泛型！ 放入盒子。
从盒子中取出了 Hello, 泛型！。
取出的消息是：Hello, 泛型！

2. 自定义泛型方法
有时候，你不需要整个类都是泛型的，只需要某个方法是泛型。

示例：创建一个交换两个变量值的泛型方法

public class Utils
{public static void Swap<T>(ref T a, ref T b){T temp = a;a = b;b = temp;Console.WriteLine($"交换后，a = {a}，b = {b}");}
}

解释：

Swap：定义了泛型方法，其中T是类型参数。
ref T a：按引用传递参数，使交换在方法外也有效。

使用泛型方法：

int x = 10;
int y = 20;
Console.WriteLine($"交换前，x = {x}，y = {y}");
Utils.Swap<int>(ref x, ref y);string s1 = "你好";
string s2 = "世界";
Console.WriteLine($"交换前，s1 = {s1}，s2 = {s2}");
Utils.Swap<string>(ref s1, ref s2);

输出：

交换前，x = 10，y = 20
交换后，a = 20，b = 10
交换前，s1 = 你好，s2 = 世界
交换后，a = 世界，b = 你好

3. 泛型约束

有时候，我们希望对类型参数进行限制，确保传入的类型具备某些特性，可以使用泛型约束。

示例：限制类型参数必须实现某个接口

public interface IAnimal
{void Speak();
}public class Dog : IAnimal
{public void Speak(){Console.WriteLine("汪汪！");}
}public class Cat : IAnimal
{public void Speak(){Console.WriteLine("喵喵！");}
}public class AnimalShelter<T> where T : IAnimal
{private List<T> animals = new List<T>();public void AddAnimal(T animal){animals.Add(animal);Console.WriteLine("添加了一只动物。");}public void LetAnimalsSpeak(){foreach (var animal in animals){animal.Speak();}}
}

解释：

where T : IAnimal：泛型约束，表示T必须是IAnimal接口的实现类。
AnimalShelter：动物收容所，可以收容任何实现了IAnimal的动物。

使用泛型约束的类：

AnimalShelter<IAnimal> shelter = new AnimalShelter<IAnimal>();
shelter.AddAnimal(new Dog());
shelter.AddAnimal(new Cat());
shelter.LetAnimalsSpeak();

输出：

添加了一只动物。
添加了一只动物。
汪汪！
喵喵！

常用的泛型约束：

where T : struct：T必须是值类型。
where T : class：T必须是引用类型。
where T : new()：T必须有一个无参数的公共构造函数。
where T : 基类名：T必须继承指定的基类。
where T : 接口名：T必须实现指定的接口。
where T : U：T必须是类型U或U的子类。

总结

泛型让你能够编写可复用、类型安全的代码。
自定义泛型类：在类名后使用，在类内部可以使用类型参数T来表示任意类型。
自定义泛型方法：在方法名前使用，方法内部可以使用类型参数T。
泛型约束：使用where关键字对类型参数进行限制，保证类型安全和功能的正确性。

动手实践

题目1：使用泛型类

任务： 创建一个自定义的泛型类Storage<T>，该类用于存储和管理一个对象。实现以下方法：
- StoreItem(T item): 存储一个项目。
- RetrieveItem(): 返回存储的项目。
要求：
1. 创建Storage<int>类型的对象，并存储整数42。
2. 创建Storage<string>类型的对象，并存储字符串"Hello, Generics"。
3. 打印存储的项目内容。
预期输出：
```
Stored integer: 42 Stored string: Hello, Generics 
```
题目2：使用泛型方法

任务： 创建一个类ArrayUtils，并在其中实现一个泛型方法FindMax<T>(T[] array)，该方法用于返回数组中最大的元素。

要求：
1. 使用FindMax<int>方法查找整数数组[2, 5, 1, 9, 6]中的最大值。
2. 使用FindMax<double>方法查找浮点数数组[1.5, 8.4, 3.2]中的最大值。
3. 打印出每个数组的最大值。
预期输出：
```
Max in integer array: 9 Max in double array: 8.4 
```
题目3：泛型约束的应用

任务： 创建一个接口IFlyable，其中包含一个方法Fly()。然后，创建一个泛型类FlyingZoo<T>，该类可以存储实现IFlyable接口的对象，并提供方法让这些对象执行飞行动作。

要求：
1. 创建类Bird和Airplane，并实现接口IFlyable。
2. 在FlyingZoo中，实现方法Add(T item)和LetThemFly()。
3. 将3个Bird对象和1个Airplane对象添加到FlyingZoo中，并执行LetThemFly()方法。
预期输出：
```
Bird is flying! Bird is flying! Bird is flying! Airplane is flying in the sky! 
```