消除重复代码的方式有许多，泛型是其中比较出色的一种，本文便来介绍一下 .Net 中的泛型。
为什么需要泛型？
在 .NET 早期（1.0时代），如果要实现一个通用的集合（如列表），通常使用 ArrayList，它存储的是 object 类型：
ArrayList list = new ArrayList();
list.Add(1); // 装箱
list.Add("text"); // 允许，但类型不安全
int num = (int)list[0]; // 需要强制转换，拆箱
这里使用的技术并不是类型擦除，ArrayList 内部存储的是 object[]，所有类型（值类型和引用类型）都可以被隐式转换为 object，值类型在加入集合时会装箱成对象，取出时必须经历拆箱步骤，并且手动进行类型转换，所以容易出错。
.NET 2.0 引入了泛型，极大地改变了集合的使用方式。以 List<T> 为例，它允许创建一个强类型的列表，指定列表中元素的类型。例如，List<int> 表示一个只存储整数的列表，可以向列表中添加整数，编译器会确保类型安全，避免像早期的 ArrayList 那样可能存放错误类型的元素：
List<int> numbers = new List<int>();
numbers.Add(1); // 无装箱
// numbers.Add("text"); // 编译错误，类型安全
int num = numbers[0]; // 无需强制转换
此时，numbers 列表只能存储整数，任何试图添加非整数的操作都会被编译器拒绝。相比之下，早期的 ArrayList 因为存储的是 object，允许放入任何类型的对象，虽然灵活但存在运行时类型转换错误的风险。
除了类型安全，泛型带来的另一个重要好处是性能的提升。早期版本的集合为了兼容所有类型，值类型在添加到集合时会被装箱，变成引用类型，这不仅增加了内存开销，还带来了拆箱时的性能损失。而泛型 List<T> 在运行时能够保留类型信息，对于值类型会生成专门的代码，不需要装箱，从而避免了额外的性能开销。
这背后的实现原理是，.NET 的泛型是“保留类型信息”的，也就是说在运行时，List<int> 和 List<string> 是两个不同的类型，各自有独立的实现细节。这种设计保证了泛型的类型安全和性能优势。
泛型的基本使用
在 .NET 中，泛型主要支持类、接口和方法，下面分别展开介绍。
泛型类
泛型类是泛型最常见的应用形式之一。定义一个泛型类时，可以使用一个或多个类型参数，来表示类中成员所使用的类型。这样就能实现类型的灵活复用，而不用为每种数据类型都写一个单独的类。
下面是一个简单的示例：
public class Box<T>
{
public T Content { get; set; }
}
这里，Box<T> 是一个泛型类，T 就是它的类型参数。Content 属性的类型由外部指定，既可以是值类型，也可以是引用类型。使用泛型类时，只需要给出具体的类型参数：
Box<int> intBox = new Box<int> { Content = 100 };
Box<string> strBox = new Box<string> { Content = "Hello" };
这样，intBox 就是一个存储整数的盒子，strBox 是存储字符串的盒子。编译器会为每个具体的类型参数生成对应的类型，实现类型安全和性能优化。
泛型类还可以定义多个类型参数：
public class Pair<T1, T2>
{
public T1 First { get; set; }
public T2 Second { get; set; }
}
var pair = new Pair<int, string> { First = 42, Second = "Answer" };
在这个例子中，Pair 类可以同时保存两个不同类型的值。
此外，泛型类可以像普通类一样，定义构造函数、方法、属性，甚至实现接口。还可以对泛型参数设置约束，限定它们必须满足某些条件，比如继承某个基类、实现某个接口或具有无参构造函数：
public class Repository<T> where T : IEntity, new()
{
public T CreateNew()
{
return new T();
}
}
这样，Repository<T> 只能用来操作实现了 IEntity 接口且有无参构造函数的类型，保证了泛型代码的安全和正确性。
通过泛型类，.NET 实现了代码的高度复用和类型安全，极大地减少了重复代码，也避免了类型转换的风险和装箱拆箱的性能损失。
泛型方法
泛型不仅可以应用于类和接口，方法同样支持泛型。通过定义泛型方法，可以让单个方法适用于多种类型，而无需为每种类型重载或编写重复代码。
下面是一个简单的泛型方法示例：
public T GetMax<T>(T a, T b) where T : IComparable<T>
{
return a.CompareTo(b) > 0 ? a : b;
}
这个方法接收两个类型为 T 的参数，并返回其中较大的一个。类型参数 T 有一个约束，要求实现 IComparable<T> 接口，这样才能调用 CompareTo 方法进行比较。
调用时，编译器能够根据传入参数自动推断泛型类型：
int max = GetMax(10, 20); // T 自动推断为 int
string greater = GetMax("apple", "banana"); // T 自动推断为 string
这样，GetMax 方法就能处理不同的数据类型，既保持了类型安全，又避免了重复编写类似的比较逻辑。
泛型方法也可以定义在非泛型类中，甚至可以定义多个类型参数：
public void Swap<T>(ref T a, ref T b)
{
T temp = a;
a = b;
b = temp;
}
这个 Swap 方法用于交换两个变量的值，适用于任何类型，无论是值类型还是引用类型。
通过泛型方法，.NET 提供了极大的灵活性，使代码更加简洁、通用且安全。
泛型接口
除了泛型类和泛型方法，泛型接口也是 .NET 泛型的重要组成部分。通过定义泛型接口，可以描述一组操作或行为，这些操作针对不同类型具有一致的规范，但具体实现可以根据类型而变化。
举个简单的例子，定义一个泛型接口 IRepository<T>，表示对某种类型数据的基本操作：
public interface IRepository<T>
{
void Add(T item);
T Get(int id);
IEnumerable<T> GetAll();
}
任何实现这个接口的类都需要针对特定的类型提供对应的方法实现：
public class UserRepository : IRepository<User>
{
private readonly List<User> users = new List<User>();
public void Add(User item)
{
users.Add(item);
}
public User Get(int id)
{
return users.FirstOrDefault(u => u.Id == id);
}
public IEnumerable<User> GetAll()
{
return users;
}
}
通过泛型接口，代码的灵活性大大增强。不同的数据类型可以使用相同的接口进行操作，而实现细节则由具体类负责。
泛型接口也可以与泛型类结合，提供更强大的抽象能力：
public class Repository<T> : IRepository<T>
{
private readonly List<T> items = new List<T>();
public void Add(T item)
{
items.Add(item);
}
public T Get(int id)
{
throw new NotImplementedException();
}
public IEnumerable<T> GetAll()
{
return items;
}
}
泛型接口同样支持约束，允许限定类型参数必须满足特定条件，保证接口的正确使用。
泛型的底层原理
在 .NET 中，泛型的支持不仅体现在语言层面，更深入到了运行时的实现。CLR（公共语言运行库）对泛型的处理机制确保了类型安全的同时，也兼顾了性能和灵活性。
当使用泛型类时，比如 List<int>，CLR 并不会简单地用一个通用的“模板”代码处理所有类型，而是在 JIT（即时编译器）阶段为每个值类型实例化单独的代码。这意味着 List<int> 和 List<long> 各自拥有专门的机器码实现，这样就避免了值类型装箱的性能开销。同时，对于引用类型的泛型实例，如 List<string> 和 List<object>，由于它们在内存中具有相同的布局，CLR 会共享一份实现代码，避免重复生成相同的机器码，从而节省内存。
这种机制带来了高效的执行性能，尤其是在处理大量值类型泛型实例时，更能体现其优势。
除了运行时的代码生成，泛型与反射的结合也非常灵活。通过反射，程序可以在运行时动态地操作泛型类型。例如，获取一个泛型类型的定义，可以写成 typeof(List<>)，这是一个未指定类型参数的泛型类型定义。基于这个定义，可以通过 MakeGenericType 方法指定具体的类型参数，从而生成具体的泛型类型。
下面是一个典型的示例：
Type listType = typeof(List<>); // 泛型类型定义，未指定类型参数
Type intListType = listType.MakeGenericType(typeof(int)); // 具体类型 List<int>
List<int> intList = (List<int>)Activator.CreateInstance(intListType); // 创建实例
intList.Add(42);
Console.WriteLine(intList[0]); // 输出 42
在这个例子中，首先获取了泛型类型定义 List<>，然后通过 MakeGenericType 指定了类型参数 int，得到了具体类型 List<int>。使用 Activator.CreateInstance 动态创建了一个该类型的实例。这样，泛型类型的创建和操作都可以在运行时灵活完成，极大提升了程序的扩展性。
总之，CLR 对泛型的支持既保证了类型安全，又在运行时通过智能代码生成和优化，实现了高效的性能表现。结合反射，泛型的使用场景变得更加广泛和灵活，满足了现代软件开发中对通用性与性能的双重需求。
若需保护泛型代码免受逆向分析或内存篡改，还可以结合 Virbox Protector 对编译后的程序进行加固，其动态解密和反调试特性可有效抵御运行时攻击，防止运行时内存被恶意分析或篡改。
泛型的高级用法
掌握了泛型类、方法、接口之后，.NET 中的泛型其实还能更进一步，用于构建更灵活、更可复用的代码结构。通过协变与逆变、默认值处理等机制，泛型变得不仅类型安全，还可以表现出强大的抽象能力。
协变（covariance）与逆变（contravariance）主要应用在泛型接口和委托中，允许在某些上下文中使用更通用或更具体的类型。比如可以这样定义一个泛型接口，并使用 out 和 in 关键字来控制类型流向：
public interface IProducer<out T>
{
T Produce();
}
public interface IConsumer<in T>
{
void Consume(T item);
}
out 修饰的类型参数支持协变，允许把 IProducer<string> 赋值给 IProducer<object>；in 修饰的类型参数支持逆变，允许把 IConsumer<object> 赋值给 IConsumer<string>。这对于泛型接口在多态环境下的使用非常有帮助，例如在事件分发、数据流模型中，经常会需要这种灵活的泛型参数兼容性。
泛型中一个容易被忽略的细节是默认值。当你写通用逻辑时，往往需要为某个类型提供一个默认实例。可以使用 default(T)：
public class Box<T>
{
public T Content { get; set; } = default(T);
}
对于值类型，default(T) 是 0 或对应的零值；对于引用类型，是 null。这种统一的默认值写法让泛型类更容易编写和维护。
同时，泛型也可以用于委托，可以定义更加通用的回调函数、事件处理器或策略接口，而无需为每种类型都单独定义一个委托类型。
举个例子，一个非常通用的泛型委托可能长这样：
public delegate T Transformer<T>(T input);
然后可以为不同类型创建不同的实例：
Transformer<int> doubleInt = x => x * 2;
Transformer<string> shout = s => s.ToUpper();
Console.WriteLine(doubleInt(10)); // 输出 20
Console.WriteLine(shout("hello")); // 输出 HELLO
这种做法可以大大减少代码重复，同时保留类型安全。再加上 .NET 自带的 Func<> 和 Action<>，你甚至不需要自己定义委托类型，大多数常见用途都可以直接用标准库提供的泛型委托来完成：
Func<int, int> square = x => x * x;
Action<string> print = s => Console.WriteLine(s);
在性能敏感的场景中，泛型类型也可以配合静态字段实现强类型缓存。这种模式非常适合做“每种类型一份”的缓存或元数据存储。
public static class TypeCache<T>
{
public static readonly string TypeName = typeof(T).FullName;
public static readonly int TypeSize = System.Runtime.InteropServices.Marshal.SizeOf(typeof(T));
}
只要访问 TypeCache<int>.TypeName 或 TypeCache<MyClass>.TypeSize，每种类型的数据都只初始化一次，且是强类型的，无需字典查找、无需类型转换。
由于泛型类在不同类型参数下是不同的静态类型，因此它可以天然地将数据隔离开，避免了并发访问中的共享问题，也省去了使用 Dictionary<Type, object> 时的装箱和查找开销。
虽然泛型带来了代码复用，但过度使用泛型也可能导致类型过多、JIT 编译开销变大，尤其是在使用大量不同值类型时。每种值类型的泛型实例都会生成一份机器码，可能造成方法数量急剧上升，影响 JIT 性能和程序集大小。
可以考虑使用一些策略进行优化：
- 使用接口或非泛型抽象层减少泛型参数组合数量；
- 对逻辑无关的部分提取为非泛型代码，减少重复；
- 使用 source generator 或 IL 重写方式，在生成阶段优化重复类型实例。
总结
泛型是一把锋利的工具，用得好可以写出极简、可复用、类型安全的代码；用得不好则可能隐藏性能问题或运行时陷阱。理解其运行机制，并遵循良好的实践，是高质量 .NET 开发不可或缺的能力。