63. 泛型方法

泛型不只能用在类上，也能用在方法上。当一个方法的核心逻辑对所有类型都一样，只是数据类型不同，就该考虑泛型方法（generic method）。

什么是泛型方法

在方法名后加 <T>，T 就成了这个方法的类型参数：

int bigger = Max(3, 7);
string longer = Max("apple", "banana");

Console.WriteLine(bigger);
Console.WriteLine(longer);

T Max<T>(T a, T b)
{
    return Comparer<T>.Default.Compare(a, b) >= 0 ? a : b;
}

输出：

7
banana

同一份 Max 逻辑，既算整数大小，也算字符串长短。不需要为 int、string 各写一遍。

类型推断省掉尖括号

调用泛型方法时，多数情况下不用写明 T。编译器根据你传入的参数自动推断（type inference）：

Show(42);          // 推断 T 为 int
Show("hi");        // 推断 T 为 string
Show(3.14);        // 推断 T 为 double

void Show<T>(T value)
{
    Console.WriteLine($"类型参数的值是：{value}");
}

只有编译器推导不出、或你想强制指定类型时，才写成 Show<int>(42)。日常写代码，让推断帮你省事。

多个类型参数

一个方法可以带多个类型参数，用逗号分开。下面的方法把两个不同类型的值打包打印：

Pair(1, "一");
Pair("id", 99);

void Pair<T1, T2>(T1 first, T2 second)
{
    Console.WriteLine($"第一个：{first}，第二个：{second}");
}

输出：

第一个：1，第二个：一
第一个：id，第二个：99

T1 和 T2 各自独立推断。这种写法在「返回多种类型组合」时很常见，比如后面会学到的元组（tuple）。

泛型方法能放在普通类里

泛型方法不要求所在类也是泛型。普通类里照样能定义泛型方法：

var helper = new Helper();
int intX = 10, intY = 20;
helper.Swap(ref intX, ref intY);
Console.WriteLine($"{intX}, {intY}");

class Helper
{
    public void Swap<T>(ref T a, ref T b)
    {
        T temp = a;
        a = b;
        b = temp;
    }
}

输出：20, 10。Helper 不是泛型类，但 Swap<T> 是泛型方法，能交换任意类型的值。

实战：打印任意集合

LINQ 里大量方法都是泛型方法。我们也写一个通用的「打印集合」：

List<string> names = ["Alice", "Bob"];
int[] numbers = [1, 2, 3];

PrintAll(names);
PrintAll(numbers);

void PrintAll<T>(IEnumerable<T> items)
{
    foreach (var item in items)
    {
        Console.Write(item + " ");
    }
    Console.WriteLine();
}

输出：

Alice Bob
1 2 3

一个 PrintAll<T> 通吃 List<T> 和数组，因为数组也实现了 IEnumerable<T>。这正是泛型方法「复用」魅力的体现。

类型推断失败怎么办

推断依赖实参。当实参类型模糊时，编译器就推断不出 T。最常见的两种：

• 传入 null：Method(null) 不知道 T 该是啥，必须写成 Method<object>(null)。
• 多个参数类型冲突：想把一个 int 和一个 string 统一成同一个 T，显然不可能，只能改成两个类型参数，或显式指定 Method<object>(a, b)。

Show<object>(42);     // 实在要统一，就显式指定
Show<object>("hi");

泛型方法 vs 写一堆重载

没有泛型方法时，为了服务多种类型，你只能写重载（overload）：

int Max(int a, int b) { ... }
string Max(string a, string b) { ... }
double Max(double a, double b) { ... }

三个方法体几乎一模一样，纯属重复。泛型方法用一份逻辑取代它们，少写代码也少出错。

在接口里写泛型方法

泛型方法也能出现在接口中，常配合默认接口方法（C# 8+）给出通用实现：

ICalc calc = new Calc();
Console.WriteLine(calc.Max(3, 9));

interface ICalc
{
    T Max<T>(T a, T b) where T : IComparable<T>
        => a.CompareTo(b) >= 0 ? a : b;
}

class Calc : ICalc { }

输出：9。实现类 Calc 一行不用写，直接继承接口里的泛型方法默认实现。这能把「与类型无关的工具逻辑」收口到接口里。

新手容易踩的坑

第一，<T> 必须写在方法名和参数列表之间，不能漏。写成 T Max(T a, T b) 就不是泛型方法，T 会被当成某个真实类型名。

第二，推断失败时要显式指定。比如两个参数类型不同又想统一成 object，需写 Method<object>(a, b)。

第三，泛型方法内部若需要调用 T 的特有方法（如比较大小），要么用 Comparer<T>，要么加约束（下一章）。否则编译器只把你当 object 看待。

第四，泛型方法参与重载解析时，编译器优先匹配「更具体」的非泛型版本。若同时有 Max(int,int) 和 Max<T>(T,T)，传入两个整数会命中前者。这通常是好事，但写库时要当心歧义。

最佳实践速览

• 方法逻辑与具体类型无关、又要服务多种类型时，用泛型方法。
• 日常调用交给类型推断，别写多余的 <T>。
• 需要调用 T 的特有成员时，用 Comparer<T> 或加约束，别靠强制转换。
• 方法只需服务一两种固定类型，直接写重载反而更清晰，不必硬上泛型。

返回「可能找不到」的结果

泛型方法配合可空返回（T?），能优雅表达「找到了就给值，否则给空」：

string? name = Find(["Alice", "Bob"], s => s.Length == 3);
Console.WriteLine(name);   // Bob

T? Find<T>(IEnumerable<T> items, Func<T, bool> match)
{
    foreach (var item in items)
    {
        if (match(item)) return item;
    }
    return default;
}

输出：Bob。没匹配到时 return default，对引用类型是 null、对值类型是 Nullable<T>。这样调用方必须面对「可能没有」的现实，逻辑更稳。

泛型方法也能带约束

前几章用 Comparer<T> 做兜底。若想让方法签名就「声明能力」，可把约束直接写进泛型方法：

int max = MaxOf([3, 9, 2, 7]);
Console.WriteLine(max);   // 9

T MaxOf<T>(IEnumerable<T> items) where T : IComparable<T>
{
    T best = default!;
    foreach (var item in items)
    {
        if (best is null || item.CompareTo(best) > 0) best = item;
    }
    return best;
}

约束让调用方一眼看出「传入的类型必须能比较」，比在方法体里偷偷用 Comparer 更诚实，也更符合「契约优先」的设计。约束的完整写法与组合，下一章系统展开。

类型推断的脾气

推断很聪明，但边界清晰：

• 实参类型一致时，直接推断该类型。
• 实参类型不兼容（如一边 int 一边 string），推断失败，必须显式写 <object> 或调整签名。
• 实参是 null，推断不出 T，必须显式指定。

// Show(3, "x");        // 编译错误：T 不能同时是 int 和 string
Show<object>(3, "x");    // 显式统一成 object 才行

小结

泛型方法把「类型」也变成参数，配合类型推断几乎无感使用。它是集合工具方法和 LINQ 的基石。记住：逻辑与具体类型无关时，泛型方法就是最佳选择。