Extension method C#: cú pháp, IEnumerable, LINQ và quy tắc

Extension method (phương thức mở rộng) thêm một phương thức vào một kiểu có sẵn mà không cần sửa, kế thừa hay bọc kiểu đó. Bạn viết một phương thức static bình thường, đánh dấu tham số đầu tiên bằng this, và nơi gọi dùng nó với cú pháp dấu chấm như thể kiểu đó vốn đã có phương thức này:

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
    }
}

Đầu ra:

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

title.Truncate(24) được biên dịch chính xác thành StringExtensions.Truncate(title, 24). Cú pháp dấu chấm chỉ để tiện: phương thức vẫn là static, vẫn nằm trong StringExtensions và chỉ dùng được các thành viên public của string.

Quy tắc khai báo

• Phương thức phải là static và nằm trong một lớp static, không generic và không lồng trong lớp khác. Lớp không static hoặc generic sẽ gây lỗi CS1106, Extension method must be defined in a non-generic static class; lớp lồng gây lỗi CS1109, Extension methods must be defined in a top level static class.
• this chỉ đặt ở tham số đầu tiên, và kiểu của tham số đó là kiểu được mở rộng. Các tham số tiếp theo là tham số bình thường.
• Bản thân phương thức có thể là generic (this IEnumerable<T> source), dù lớp thì không được.
• Nó chỉ thấy những gì mọi code bên ngoài thấy: các thành viên public (và internal, trong cùng assembly). Trường private vẫn là private.

Quy ước là đặt tên lớp theo kiểu được mở rộng (StringExtensions, EnumerableExtensions) và gom chúng vào một namespace như MyApp.Extensions.

Mở rộng interface và IEnumerable<T>

Mở rộng một interface sẽ thêm phương thức cho mọi kiểu cài đặt interface đó. Vì vậy, mở rộng IEnumerable<T> sẽ đồng thời trao phương thức cho mảng, list, set, tập khóa của từ điển và kết quả truy vấn 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)));
    }
}

Đầu ra:

9.5
50
65
f0 f3 f6

EveryNth là generic: T được suy ra từ receiver, nên ở đây nó chạy với chuỗi và cũng chạy với mọi kiểu phần tử khác. Vì dùng yield return, nó lười (lazy) giống các toán tử LINQ có sẵn và có thể nối chuỗi với chúng.

LINQ được xây dựng trên extension method

Where, Select, OrderBy, Sum, First và phần còn lại của LINQ là các extension method trên IEnumerable<T>, được định nghĩa trong lớp static System.Linq.Enumerable. Đó là lý do using System.Linq; phải có ở đầu tệp thì list.Where(...) mới biên dịch được, và là lý do LINQ chạy được với mọi kiểu collection mà không kiểu nào phải tự cài đặt phương thức 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));
    }
}

Đầu ra:

72, 88, 95
72, 88, 95

Hai dòng này là cùng một code. Cú pháp extension biến các lời gọi lồng nhau, vốn phải đọc từ trong ra ngoài, thành một chuỗi đọc theo đúng thứ tự các bước diễn ra. Đây là lý do chính extension method ra đời: chúng được thêm vào C# 3 cùng với LINQ. Trang LINQ trình bày các toán tử.

Phải import namespace

Extension method chỉ nằm trong phạm vi khi namespace của lớp static chứa nó được import bằng using. Không có using, lời gọi thất bại như thể phương thức không tồn tại:

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?)

Thêm using cho namespace chứa các extension (hoặc, từ C# 10, một global using duy nhất cho cả dự án):

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());
    }
}

Đầu ra:

EUR 49.90

Mặt ngược lại lại có ích: một extension method bạn không muốn xuất hiện ở khắp nơi có thể nằm trong một namespace mà chỉ vài tệp import.

Phương thức instance được ưu tiên

Khi một kiểu đã có sẵn phương thức instance phù hợp, trình biên dịch dùng nó và không bao giờ xét đến extension. Một extension cùng chữ ký là code chết ở mọi chỗ gọi dùng cú pháp dấu chấm:

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));
    }
}

Đầu ra:

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

Extension một đối số đã thua phương thức instance; extension hai đối số được dùng vì không có phương thức instance nào nhận một chuỗi. Điều này cũng có nghĩa là một bản cập nhật thư viện thêm phương thức instance trùng tên với extension của bạn sẽ âm thầm chuyển các lời gọi của bạn sang phiên bản của thư viện. Hãy chọn tên extension khó bị trùng.

Gọi trên null

Vì lời gọi thực chất là lời gọi static, receiver null không ném ngoại lệ tại chỗ gọi. Phương thức nhận null làm đối số đầu tiên và tự quyết định điều đó có nghĩa gì:

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}");
        }
    }
}

Đầu ra:

True
AL
ArgumentNullException: fullName

missing.IsBlank() trả về true thì tiện, nhưng có thể khiến người đọc bất ngờ vì họ nghĩ gọi thành viên trên null sẽ ném ngoại lệ. Chỉ chấp nhận null ở những phương thức có tên nói rõ điều đó (IsBlank, OrEmpty); ở những chỗ khác, hãy ném ArgumentNullException như LINQ.

Mở rộng enum

Enum không thể có phương thức riêng, nên đây là đối tượng rất hợp để mở rộng:

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()) { ... }

Extension member trong C# 14

Đến trước C# 14, chỉ phương thức mới làm extension được. C# 14 bổ sung khối extension, gom các thành viên cho một receiver và cho phép cả extension property lẫn thành viên static:

// 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] + "...";
    }
}

Extension method kiểu cổ điển với tham số this vẫn hợp lệ và là thứ gần như mọi code và thư viện hiện có đang dùng.

Khi nào nên viết extension method

Extension method phù hợp khi bạn không sở hữu kiểu đó (string, DateTime, interface của framework), khi bạn muốn cùng một helper cho mọi lớp cài đặt một interface, hoặc khi một chuỗi lời gọi dễ đọc hơn các lời gọi lồng nhau. Khi bạn sở hữu lớp, hãy thêm một phương thức instance thật: nó dùng được trạng thái private và nằm đúng chỗ người đọc tìm. Và tránh mở rộng object, vì việc đó đưa phương thức của bạn vào danh sách gợi ý của mọi giá trị trong chương trình.