C# 扩展方法：语法、IEnumerable、LINQ 与规则

扩展方法可以给已有的类型添加方法，而不需要修改它、继承它或包装它。你写一个普通的静态方法，用 this 标记它的第一个参数，调用方就能用点语法使用它，就好像这个类型本来就有这个方法一样：

using System;

static class StringExtensions
{
    public static string Truncate(this string text, int maxLength)
    {
        if (text.Length <= maxLength) return text;
        return text.Substring(0, maxLength) + "...";
    }

    public static int WordCount(this string text) =>
        text.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Length;
}

class Program
{
    static void Main()
    {
        string title = "Extension methods let you add behavior to types you do not own";

        Console.WriteLine(title.Truncate(24));
        Console.WriteLine(title.WordCount());
        Console.WriteLine("short".Truncate(24));

        Console.WriteLine(StringExtensions.Truncate(title, 9));   // the same method, called directly
    }
}

输出：

Extension methods let yo...
12
short
Extension...

title.Truncate(24) 会被编译成完全等同的 StringExtensions.Truncate(title, 24)。点语法只是一种便利：方法仍然是静态的，仍然位于 StringExtensions 中，而且只能使用 string 的公共成员。

声明扩展方法的规则

• 方法必须是 static 的，并且位于一个 static、非泛型、没有嵌套在其他类中的类里。非静态或泛型的类会报 CS1106：Extension method must be defined in a non-generic static class；嵌套的类会报 CS1109：Extension methods must be defined in a top level static class。
• this 只能放在第一个参数上，这个参数的类型就是被扩展的类型。其余参数都是普通参数。
• 方法本身可以是泛型的（this IEnumerable<T> source），即使类不能是泛型的。
• 它能看到的只有任何外部代码都能看到的东西：公共成员（以及同一程序集内的 internal 成员）。私有字段仍然是私有的。

惯例是按被扩展的类型给类命名（StringExtensions、EnumerableExtensions），并把它们归到 MyApp.Extensions 这样的命名空间中。

扩展接口与 IEnumerable<T>

扩展一个接口，就等于给实现它的每一个类型都加上了这个方法。因此，扩展 IEnumerable<T> 会一次性把方法加给数组、列表、集合、字典的键集合以及 LINQ 查询结果：

using System;
using System.Collections.Generic;
using System.Linq;

static class EnumerableExtensions
{
    public static decimal Median(this IEnumerable<decimal> source)
    {
        var sorted = source.OrderBy(x => x).ToList();
        if (sorted.Count == 0) throw new InvalidOperationException("sequence is empty");
        int mid = sorted.Count / 2;
        return sorted.Count % 2 == 1 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
    }

    public static IEnumerable<T> EveryNth<T>(this IEnumerable<T> source, int n)
    {
        int i = 0;
        foreach (T item in source)
        {
            if (i % n == 0) yield return item;
            i++;
        }
    }
}

class Program
{
    static void Main()
    {
        decimal[] prices = { 12m, 3m, 45m, 7m };
        var orderTotals = new List<decimal> { 20m, 80m, 50m };

        Console.WriteLine(prices.Median());
        Console.WriteLine(orderTotals.Median());
        Console.WriteLine(orderTotals.Where(t => t > 25m).Median());

        string[] frames = { "f0", "f1", "f2", "f3", "f4", "f5", "f6" };
        Console.WriteLine(string.Join(" ", frames.EveryNth(3)));
    }
}

输出：

9.5
50
65
f0 f3 f6

EveryNth 是泛型的：T 从接收者推断出来，所以它在这里用于字符串，也适用于任何其他元素类型。因为它使用了 yield return，所以它和内置的 LINQ 运算符一样是延迟执行的，并且可以与它们链式调用。

LINQ 建立在扩展方法之上

Where、Select、OrderBy、Sum、First 以及 LINQ 的其余部分，都是 IEnumerable<T> 上的扩展方法，定义在静态类 System.Linq.Enumerable 中。这就是为什么文件顶部必须有 using System.Linq;，list.Where(...) 才能编译通过；也是为什么 LINQ 能用于每一种集合类型，而它们没有一个实现了 Where 方法：

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] scores = { 72, 95, 58, 88 };

        var passed1 = scores.Where(s => s >= 60).OrderBy(s => s);
        var passed2 = Enumerable.OrderBy(Enumerable.Where(scores, s => s >= 60), s => s);

        Console.WriteLine(string.Join(", ", passed1));
        Console.WriteLine(string.Join(", ", passed2));
    }
}

输出：

72, 88, 95
72, 88, 95

这两行是同样的代码。扩展语法把从里往外读的嵌套调用，变成了按步骤发生顺序阅读的链式调用，这正是扩展方法存在的主要原因：它们是在 C# 3 中与 LINQ 一起加入的。LINQ 那一页介绍了各个运算符。

必须导入命名空间

只有用 using 导入了扩展方法所在静态类的命名空间，它才在作用域内。否则调用会失败，就好像这个方法不存在一样：

error CS1061: 'string' does not contain a definition for 'Truncate' and no accessible extension method 'Truncate' accepting a first argument of type 'string' could be found (are you missing a using directive or an assembly reference?)

为扩展方法的命名空间加上 using（或者从 C# 10 起，为整个项目写一次 global using）：

using System;
using Shop.Extensions;

namespace Shop.Extensions
{
    public static class PriceExtensions
    {
        public static string ToPriceTag(this decimal amount) => $"EUR {amount:F2}";
    }
}

class Program
{
    static void Main()
    {
        decimal total = 49.9m;
        Console.WriteLine(total.ToPriceTag());
    }
}

输出：

EUR 49.90

反过来看，这一点也很有用：不想到处可见的扩展方法，可以放在只有部分文件才导入的命名空间里。

实例方法优先

如果类型已经有一个适用的实例方法，编译器就会用它，根本不会考虑扩展方法。签名相同的扩展方法，在每个使用点语法的调用处都是无效代码：

using System;

class Invoice
{
    public decimal Amount = 120m;
    public string Describe() => $"Invoice (instance method): {Amount}";
}

static class InvoiceExtensions
{
    public static string Describe(this Invoice invoice) => "extension: only reachable as a static call";
    public static string Describe(this Invoice invoice, string currency) =>
        $"Invoice (extension): {invoice.Amount} {currency}";
}

class Program
{
    static void Main()
    {
        var invoice = new Invoice();
        Console.WriteLine(invoice.Describe());
        Console.WriteLine(invoice.Describe("USD"));
        Console.WriteLine(InvoiceExtensions.Describe(invoice));
    }
}

输出：

Invoice (instance method): 120
Invoice (extension): 120 USD
extension: only reachable as a static call

只有一个参数的扩展方法输给了实例方法；有两个参数的那个被使用了，因为没有哪个实例方法接收字符串参数。这也意味着，如果库的某次更新添加了一个与你的扩展方法同名的实例方法，你的调用就会悄无声息地切换到库的版本。请选择不太可能冲突的扩展方法名。

在 null 上调用

由于这个调用实际上是静态调用，null 接收者不会在调用处抛出异常。方法收到 null 作为第一个实参，并决定这意味着什么：

using System;

static class TextExtensions
{
    public static bool IsBlank(this string s) => string.IsNullOrWhiteSpace(s);

    public static string Initials(this string fullName)
    {
        if (fullName == null) throw new ArgumentNullException(nameof(fullName));
        string result = "";
        foreach (string part in fullName.Split(' '))
            if (part.Length > 0) result += char.ToUpper(part[0]);
        return result;
    }
}

class Program
{
    static void Main()
    {
        string missing = null;

        Console.WriteLine(missing.IsBlank());
        Console.WriteLine("ada lovelace".Initials());

        try
        {
            missing.Initials();
        }
        catch (ArgumentNullException e)
        {
            Console.WriteLine($"{e.GetType().Name}: {e.ParamName}");
        }
    }
}

输出：

True
AL
ArgumentNullException: fullName

missing.IsBlank() 返回 true 很方便，但可能会让以为在 null 上调用成员就会抛出异常的读者感到意外。只在名称一看就明白的方法中接受 null（IsBlank、OrEmpty）；其他地方，像 LINQ 那样抛出 ArgumentNullException。

扩展枚举

枚举不能有自己的方法，这让它们成为扩展方法的天然目标：

enum OrderStatus { Pending, Paid, Shipped, Delivered, Cancelled }

static class OrderStatusExtensions
{
    public static bool IsFinal(this OrderStatus s) =>
        s == OrderStatus.Delivered || s == OrderStatus.Cancelled;
}

// usage: if (order.Status.IsFinal()) { ... }

C# 14 中的扩展成员

在 C# 14 之前，只有方法可以作为扩展。C# 14 新增了 extension 块，它把同一个接收者的成员归在一起，还允许扩展属性和静态成员：

// C# 14 and later
public static class StringExtensions
{
    extension(string s)
    {
        public bool IsBlank => string.IsNullOrWhiteSpace(s);   // extension property
        public string Truncate(int max) => s.Length <= max ? s : s[..max] + "...";
    }
}

经典的 this 参数扩展方法依然有效，几乎所有现有代码和库用的都是它。

什么时候该写扩展方法

当类型不归你所有（string、DateTime、框架接口）、当你希望某个接口的每个实现都有同一个辅助方法，或者当链式调用比嵌套调用更易读时，扩展方法很合适。如果类是你自己的，就直接添加真正的实例方法：它可以使用私有状态，而且出现在读者会去找的地方。另外，避免扩展 object，那会让你的方法出现在程序中每个值的自动补全列表里。