泛型

是什么，为什么存在

泛型（generic） 声明把一个或多个类型留作参数。类、结构、接口、委托和方法都可以声明 类型参数（type parameter） ，通常写作 T、TKey 或 TResult。使用方提供类型实参后，List<string> 或 Dictionary<string, int> 这样的构造类型才确定下来。

泛型解决的是类型关系复用，而不只是少写几份代码。T Find<T>(IEnumerable<T> source) 表明返回值与序列元素是同一种类型；若改成 object Find(IEnumerable source)，这种关系会消失，调用方只能强制转换并承担运行时失败。

值类型通过 object 传递时通常发生 装箱（boxing） ，取回时还要拆箱。List<int> 直接按 int 存取元素，既保留编译期检查，也不需要为了集合的每个元素先转换成 object。这不表示所有泛型代码都零分配，只说明它避免了这条特定转换路径。

你会在集合、LINQ、委托、异步 API、依赖注入和序列化库中反复遇到泛型。读取 IEnumerable<Order> 时，尖括号里的类型不是文档装饰，而是编译器和运行时都能使用的契约组成部分。

泛型适合多种类型共享同一算法，而且算法只依赖一组明确能力的场景。如果不同类型需要完全不同的业务流程，堆叠类型检查和 typeof(T) 分支通常是在隐藏多个实现；接口、多态或独立服务会更清楚。

工作原理

声明与构造是两个阶段

Cache<TKey, TValue> 声明两个类型参数。Cache<string, Product> 提供两个类型实参，形成封闭构造类型；参数个数、顺序和约束都必须匹配。Cache<,> 表示未绑定泛型类型，只能用于 typeof 和反射等元数据操作，不能直接创建实例。

同一个类型参数在多个位置出现时，编译器会保持它们相等。下面的签名要求 item、fallback 和返回值都使用同一个 T，调用方不能把互不相关的类型混在一次调用中。

static T Choose<T>(bool useItem, T item, T fallback) =>
    useItem ? item : fallback;

泛型方法的类型参数属于方法，不要求包含它的类型也是泛型。调用 Choose(true, 10, 20) 时，编译器从实参推断 T 为 int。方法类型推断不靠返回值猜测 T，推断失败或结果不符合约束时，调用方必须调整实参或明确写出类型实参。

约束开放可用能力

没有约束的 T 只能使用所有类型都具备的操作，例如赋值、object 成员和 EqualityComparer<T>.Default。 泛型约束（generic constraint） 通过 where 子句缩小可接受类型，同时让泛型实现可以调用约束保证的成员。

约束是编译期规则，不是业务验证器。where T : class 不会阻止旧代码、反射或关闭可空分析的调用方传入 null；where T : new() 也不能证明新对象已满足领域不变量。公开边界仍要检查实际值。

多个约束的顺序受语法限制：引用类型、值类型或 unmanaged 等主约束放在前面，基类或接口约束随后，new() 靠后。allows ref struct 是反约束，表示实现遵守 ref struct 的安全规则；它必须位于其他约束之后，不能把类型实参当作可以装箱或跨 await 保存的普通值。

相等、比较与运算符需要协议

对未知 T 使用 == 并不总能编译，也未必表达领域需要的相等性。普通相等查找应使用 EqualityComparer<T>.Default，排序可以接收 IComparer<T>，需要调用 CompareTo 时才添加 IComparable<T> 约束。这样，值类型、引用类型和调用方提供的比较策略走同一条明确路径。

C# 的接口可以声明静态抽象成员。INumber<TSelf> 等泛型数学接口因此能让受约束代码使用 T.Zero 和 +，而不必改用 dynamic。这是一个真正的能力约束：调用方只能提供实现所需静态协议的类型。

不要为了方便随手添加 new()、class 或某个宽泛接口。约束会成为公开 API 的兼容性边界；算法没有使用的约束只会排除原本有效的类型，并让以后移除约束成为设计修正。

变体控制引用转换方向

变体（variance） 描述已有引用类型转换怎样传播到泛型接口或委托。IEnumerable<out T> 是协变的，所以 IEnumerable<string> 可以赋给 IEnumerable<object>；它只从接口输出 T，调用方无法通过该接口写入一个任意 object。

IComparer<in T> 是逆变的。能比较任意 Animal 的比较器当然也能比较两个 Dog，所以 IComparer<Animal> 可以用于需要 IComparer<Dog> 的位置。方向看起来相反，是因为 T 只作为输入进入接口。

只有接口和委托的类型参数可以声明 out 或 in，泛型类本身始终不变。即使 Dog 派生自 Animal，List<Dog> 也不能赋给 List<Animal>；否则接收方就能加入一只不是 Dog 的 Animal。变体转换也只适用于引用类型实参，IEnumerable<int> 不会因此转换成 IEnumerable<object>。

示例

四个示例依次展示类型关系、约束提供的静态能力、变体转换和运行时类型身份。当前环境没有 .NET SDK 或 C# 编译器，因此代码块按仓库约定标明未执行，输出块不伪造结果。

用类型参数保留查找结果

这个查找方法把元素、目标值和比较器绑定到同一个 T。调用方从 string?[] 实参得到 string? 推断，不需要把元素转换成 object。

EqualityComparer<T>.Default 能处理示例中的两个 null 操作数，也会采用具体类型的默认相等规则。方法返回索引而不是 default(T)，所以「没有找到」不会和元素类型的合法默认值混在一起。

真实 API 还要决定 items 本身能否为 null。可空注解可以表达预期并产生警告，但跨越反射、反序列化或未启用可空分析的边界时，若契约要求拒绝 null，仍应执行运行时检查。

用静态抽象成员实现泛型求和

INumber<T> 保证 T.Zero 和加法可用。实现既没有按具体数值类型分支，也没有把运算推迟给 dynamic。

// # not executed here: the .NET SDK and C# compilers are unavailable
using System;
using System.Collections.Generic;
using System.Numerics;

int[] units = [2, 3, 5];
decimal[] prices = [1.25m, 2.50m, 4.00m];

Console.WriteLine(Sum(units));
Console.WriteLine(Sum(prices));

static T Sum<T>(IEnumerable<T> values) where T : INumber<T>
{
    T total = T.Zero;

    foreach (T value in values)
        total += value;

    return total;
}

# not executed here: the .NET SDK and C# compilers are unavailable

空序列会返回 T.Zero，这是该方法明确选择的数学单位元。这个结果不一定适合平均值、最大值或业务金额校验；那些操作需要各自定义空输入契约，而不是照搬求和行为。

若只需要加法和零值，可以约束更窄的操作符接口，而不是整个 INumber<T>。约束应跟随实现真正调用的成员，这能让自定义数值类型更容易满足 API。

分开读取方与写入方

生产者只返回 T，因此声明 out T；接收器只接收 T，因此声明 in T。赋值方向由这两个接口位置决定，并没有改变具体对象的运行时类型。

// # not executed here: the .NET SDK and C# compilers are unavailable
using System;

IProducer<Dog> dogSource = new DogSource();
IProducer<Animal> animalSource = dogSource;

IConsumer<Animal> animalSink = new AnimalSink();
IConsumer<Dog> dogSink = animalSink;

Animal animal = animalSource.Create();
dogSink.Save(new Dog("Rex"));
Console.WriteLine(animal.Name);

public interface IProducer<out T>
{
    T Create();
}

public interface IConsumer<in T>
{
    void Save(T value);
}

public sealed class DogSource : IProducer<Dog>
{
    public Dog Create() => new("Milo");
}

public sealed class AnimalSink : IConsumer<Animal>
{
    public void Save(Animal value) =>
        Console.WriteLine($"saved: {value.Name}");
}

public record Animal(string Name);
public sealed record Dog(string Name) : Animal(Name);

# not executed here: the .NET SDK and C# compilers are unavailable

animalSource 的静态类型只承诺产生 Animal，但实际对象仍是 DogSource，产生的实例仍是 Dog。dogSink 只能被调用来保存 Dog，而底层 AnimalSink 本来就能处理这种输入。

若一个接口既接收又返回同一个 T，通常不能把该参数标为协变或逆变。把读取和写入能力拆成两个窄接口，有时能得到安全的变体转换；拆分是否合适仍取决于领域契约。

观察构造类型的运行时身份

运行时保留泛型类型实参。示例还展示了泛型静态类的字段按封闭构造类型分别存在。

// # not executed here: the .NET SDK and C# compilers are unavailable
using System;
using System.Collections.Generic;

Type integers = typeof(List<int>);
Type strings = typeof(List<string>);

Console.WriteLine(integers == strings);
Console.WriteLine(integers.GetGenericTypeDefinition() == typeof(List<>));
Console.WriteLine(string.Join(", ", integers.GetGenericArguments()));

TypeSlot<int>.Label = "quantities";
TypeSlot<string>.Label = "names";

Console.WriteLine(TypeSlot<int>.Label);
Console.WriteLine(TypeSlot<string>.Label);

public static class TypeSlot<T>
{
    public static string Label { get; set; } = typeof(T).Name;
}

# not executed here: the .NET SDK and C# compilers are unavailable

List<int> 与 List<string> 是不同的构造类型，但两者的泛型类型定义都是 List<>。反射代码需要先分清拿到的是定义还是封闭类型，再决定调用 GetGenericArguments()、MakeGenericType() 或创建实例。

TypeSlot<int>.Label 和 TypeSlot<string>.Label 不共享字段。这种行为可用于按类型缓存元数据，但缓存仍需要容量与生命周期设计；类型数量来自不受控动态输入时，泛型静态字段不是自动有界的缓存。

陷阱

用 object 或 dynamic 绕过设计问题

修复方法： 先写出算法需要的最小协议。相等使用 IEqualityComparer<T>，排序使用 IComparer<T>，静态运算使用带静态抽象成员的接口；不同业务行为则用多态或独立实现，不要用 dynamic 掩盖。

把 default(T) 当作未找到

修复方法： 返回索引、布尔值加 out T、可辨识的结果类型，或在契约适合时返回可空值。选择必须同时覆盖值类型、引用类型和实际业务含义。

用 new() 代替对象创建契约

修复方法： 让调用方传入 Func<T> 或领域工厂，或者约束到真正描述创建协议的接口。只有空对象本来就有效，而且泛型实现确实负责创建时，才使用 new()。

把所有泛型集合都当作协变

修复方法： 查看实际接口声明中的 out 或 in，并检查类型实参是否是引用类型。只读消费方可接收协变接口；需要修改时，保留准确元素类型或显式复制到新的目标集合。

认为可空约束已经检查了值

修复方法： 用约束表达类型级意图，用 ArgumentNullException.ThrowIfNull 等运行时检查保护真实边界。测试来自反射、反序列化、旧程序集和禁用可空上下文的输入。

添加算法没有使用的约束

修复方法： 为约束中的每项能力找到实现里的实际使用位置。找不到就删除；业务数据规则应放进参数验证或领域类型，而不是借类型约束表达。

延伸阅读

• C# 泛型概述
• 类型参数约束
• 泛型接口中的变体
• .NET 运行时中的泛型
• C# 语言规范中的构造类型