C#中的泛型允许我们在定义类、方法、接口等成员时，不预先指定具体的类型，而是用一个类型参数来占位，在使用时再指定具体类型，这样既保证了类型安全，又避免了不必要的装箱拆箱操作，大幅提升了代码的复用性。
泛型类的基本使用
泛型类是在类定义时声明类型参数的类，类型参数通常用大写字母T表示，也可以自定义有意义的名称。定义泛型类后，我们可以在类的属性、方法、字段中使用这个类型参数。
下面是一个简单的泛型类示例，实现一个可以存储任意类型数据的容器：
// 定义泛型类，T是类型参数
public class DataContainer<T>
{
// 用类型参数T定义属性
public T Data { get; set; }
// 用类型参数T作为方法参数
public void SetData(T value)
{
Data = value;
}
// 用类型参数T作为返回值
public T GetData()
{
return Data;
}
}
使用这个泛型类时，只需要指定具体的类型参数即可：
// 指定T为int类型
DataContainer<int> intContainer = new DataContainer<int>();
intContainer.SetData(100);
Console.WriteLine(intContainer.GetData()); // 输出100
// 指定T为string类型
DataContainer<string> strContainer = new DataContainer<string>();
strContainer.SetData("hello generic");
Console.WriteLine(strContainer.GetData()); // 输出hello generic
泛型方法的使用
泛型方法不一定需要定义在泛型类中，普通类也可以包含泛型方法。泛型方法的类型参数定义在方法名后面，调用时可以显式指定类型参数，也可以让编译器自动推断。
下面是一个普通类中的泛型方法示例，实现两个相同类型值的交换：
public class Utility
{
// 泛型方法，类型参数T定义在方法名后
public static void Swap<T>(ref T a, ref T b)
{
T temp = a;
a = b;
b = temp;
}
}
调用泛型方法的方式如下：
int num1 = 10, num2 = 20;
// 显式指定类型参数为int
Utility.Swap<int>(ref num1, ref num2);
Console.WriteLine($"num1:{num1}, num2:{num2}"); // 输出num1:20, num2:10
string str1 = "aaa", str2 = "bbb";
// 编译器自动推断类型参数为string，无需显式指定
Utility.Swap(ref str1, ref str2);
Console.WriteLine($"str1:{str1}, str2:{str2}"); // 输出str1:bbb, str2:aaa
泛型约束
有时候我们需要限制类型参数可以接受的类型范围，这时候就可以使用泛型约束。常见的泛型约束有以下几种：
- where T : struct：类型参数必须是值类型
- where T : class：类型参数必须是引用类型
- where T : new()：类型参数必须有无参数的公共构造函数
- where T : 基类名：类型参数必须是指定基类或派生自该基类
- where T : 接口名：类型参数必须实现指定的接口
下面是一个带泛型约束的示例，要求类型参数必须实现IComparable<T>接口，这样才能进行比较操作：
// 泛型约束：T必须实现IComparable<T>接口
public class CompareHelper<T> where T : IComparable<T>
{
public static T GetMax(T a, T b)
{
// 调用接口定义的方法进行比较
if (a.CompareTo(b) > 0)
{
return a;
}
return b;
}
}
使用这个泛型类时，传入的类型必须实现IComparable<T>接口，比如int、string等内置类型都实现了该接口：
int maxInt = CompareHelper<int>.GetMax(30, 50);
Console.WriteLine(maxInt); // 输出50
string maxStr = CompareHelper<string>.GetMax("abc", "abd");
Console.WriteLine(maxStr); // 输出abd
泛型的高级特性
协变与逆变
协变和逆变主要用于泛型接口和泛型委托，用来处理类型参数的继承转换关系。协变用out关键字修饰，允许返回派生程度更大的类型；逆变用in关键字修饰，允许传入派生程度更小的类型。
下面是一个协变的示例：
// 协变接口，T用out修饰，只能作为返回值
public interface IFactory<out T>
{
T Create();
}
public class AnimalFactory : IFactory<Animal>
{
public Animal Create()
{
return new Animal();
}
}
public class DogFactory : IFactory<Dog>
{
public Dog Create()
{
return new Dog();
}
}
public class Animal { }
public class Dog : Animal { }
class Program
{
static void Main()
{
// Dog是Animal的子类，所以IFactory<Dog>可以赋值给IFactory<Animal>
IFactory<Animal> factory = new DogFactory();
Animal animal = factory.Create();
}
}
泛型与反射
我们也可以通过反射来操作泛型类型和泛型方法，比如动态创建泛型类型的实例、调用泛型方法等。下面是一个通过反射创建泛型类实例的示例：
using System;
using System.Reflection;
public class GenericClass<T>
{
public void ShowType()
{
Console.WriteLine($"当前类型参数的类型是：{typeof(T)}");
}
}
class Program
{
static void Main()
{
// 获取泛型类的类型定义
Type genericTypeDefinition = typeof(GenericClass<>);
// 指定类型参数为string，构造具体的泛型类型
Type constructedType = genericTypeDefinition.MakeGenericType(typeof(string));
// 创建实例
object instance = Activator.CreateInstance(constructedType);
// 调用方法
MethodInfo method = constructedType.GetMethod("ShowType");
method.Invoke(instance, null); // 输出当前类型参数的类型是：System.String
}
}
使用泛型的注意事项
- 泛型类型参数不能是基本类型，比如不能直接用
int?作为类型参数，不过可以用Nullable<int>代替 - 静态字段在每一个封闭的泛型类型中都有独立的一份，比如
GenericClass<int>和GenericClass<string>的静态字段是互相独立的 - 泛型不支持运算符直接重载，比如不能直接对类型参数T使用+、-等运算符，除非添加对应的约束或者改用其他方法实现