Ném ngoại lệ trong C#: guard clause, throw expression, ngoại lệ tự tạo

Bắt ngoại lệ (exception) mới là một nửa của việc xử lý lỗi; nửa còn lại là ném đúng ngoại lệ. Một ngoại lệ được chọn kỹ cho nơi gọi biết chính xác điều gì đã sai, và đó là lỗi của họ hay do trạng thái của chương trình. Trang này nói về phía ném; phần xử lý nằm ở try catch.

Câu lệnh throw và guard clause

throw nhận một đối tượng ngoại lệ. Phương thức dừng chạy tại đó, và ngoại lệ đi ngược lên call stack để tìm trình xử lý. Cách dùng phổ biến nhất là guard clause: các bước kiểm tra ở đầu phương thức, từ chối đầu vào không hợp lệ trước khi làm bất cứ việc gì.

using System;

class Account
{
    public decimal Balance { get; private set; }
    public bool Frozen { get; set; }

    public void Withdraw(decimal amount)
    {
        if (amount <= 0)
            throw new ArgumentOutOfRangeException(nameof(amount), "Amount must be positive.");
        if (Frozen)
            throw new InvalidOperationException("The account is frozen.");
        if (amount > Balance)
            throw new InvalidOperationException("Insufficient funds.");

        Balance -= amount;
    }

    public void Deposit(decimal amount)
    {
        if (amount <= 0)
            throw new ArgumentOutOfRangeException(nameof(amount), "Amount must be positive.");
        Balance += amount;
    }
}

class Program
{
    static void Main()
    {
        var acct = new Account();
        acct.Deposit(100m);

        try
        {
            acct.Withdraw(-5m);
        }
        catch (ArgumentOutOfRangeException e)
        {
            Console.WriteLine(e.GetType().Name + " for parameter '" + e.ParamName + "'");
        }

        acct.Frozen = true;
        try
        {
            acct.Withdraw(20m);
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine(e.GetType().Name + ": " + e.Message);
        }

        Console.WriteLine("Balance: " + acct.Balance);
    }
}

Đầu ra:

ArgumentOutOfRangeException for parameter 'amount'
InvalidOperationException: The account is frozen.
Balance: 100

nameof(amount) tạo ra chuỗi "amount" và vẫn đúng nếu tham số được đổi tên. Các ngoại lệ về đối số lưu chuỗi này trong ParamName, để công cụ và log chỉ ra đúng đối số bị sai.

Guard clause giúp phần còn lại của phương thức đơn giản: qua được các bước kiểm tra, code có thể coi đầu vào là hợp lệ. Chúng cũng báo lỗi ngay tại chỗ sai, thay vì để một giá trị hỏng trôi tiếp và gây ra một NullReferenceException khó hiểu ba phương thức sau đó.

Nên ném kiểu ngoại lệ nào

Hãy dùng lại một kiểu có sẵn khi nó mô tả đúng tình huống; nơi gọi đã biết cách xử lý nó.

Ranh giới giữa ba hàng đầu và InvalidOperationException nằm ở chỗ ai cần thay đổi. Ngoại lệ về đối số nói "hãy gọi theo cách khác". InvalidOperationException nói "lời gọi không sai, nhưng chưa phải lúc".

Đừng ném trực tiếp Exception, SystemException hay ApplicationException: nơi gọi không thể bắt chúng mà không bắt luôn mọi thứ khác. Cũng đừng tự ném NullReferenceException, IndexOutOfRangeException hay StackOverflowException; runtime dành riêng các kiểu này cho bug thật.

Throw expression

Trước C# 7, throw chỉ là một câu lệnh. Từ C# 7, nó còn có thể xuất hiện như một biểu thức ở ba chỗ, giúp các bước kiểm tra quen thuộc gọn lại thành một dòng:

using System;

class Customer
{
    private readonly string name;
    private readonly string email;

    public Customer(string name, string email)
    {
        this.name = name ?? throw new ArgumentNullException(nameof(name));       // after ??
        this.email = email.Contains("@")
            ? email
            : throw new ArgumentException("Not an email address.", nameof(email)); // in ?:
    }

    public string Name => name;

    public string Nickname => throw new NotImplementedException();                // expression body

    public override string ToString() => name + " <" + email + ">";
}

class Program
{
    static void Main()
    {
        Console.WriteLine(new Customer("Ana", "ana@example.com"));

        try
        {
            new Customer(null, "x@example.com");
        }
        catch (ArgumentNullException e)
        {
            Console.WriteLine("Null: " + e.ParamName);
        }

        try
        {
            new Customer("Ben", "ben.example.com");
        }
        catch (ArgumentException e)
        {
            Console.WriteLine(e.GetType().Name + ": " + e.ParamName);
        }
    }
}

Đầu ra:

Ana <ana@example.com>
Null: name
ArgumentException: email

Lưu ý ArgumentNullException kế thừa từ ArgumentException, nên một catch (ArgumentException) đặt trước sẽ bắt luôn trường hợp null. Cũng vì vậy mà thứ tự các mệnh đề catch quan trọng khi bạn xử lý cả hai.

ThrowIfNull và các helper tương tự (.NET 6 trở lên)

.NET hiện đại có thêm các helper tĩnh viết sẵn bước kiểm tra và lệnh ném cho bạn, tên tham số được lấy tự động:

public void Ship(Order order, int quantity, string address)
{
    ArgumentNullException.ThrowIfNull(order);                   // .NET 6
    ArgumentOutOfRangeException.ThrowIfNegativeOrZero(quantity); // .NET 8
    ArgumentException.ThrowIfNullOrWhiteSpace(address);          // .NET 8
    ObjectDisposedException.ThrowIf(disposed, this);             // .NET 7

    // ...
}

Chúng hoạt động giống hệt if và throw viết tay, và giữ mỗi guard clause trong một dòng. Với các phiên bản cũ hơn, hãy viết theo dạng if ở trên.

Viết lớp ngoại lệ tự tạo

Hãy tạo kiểu ngoại lệ riêng khi nơi gọi cần bắt riêng lỗi cụ thể này, hoặc khi trình xử lý cần dữ liệu mà một chuỗi thông báo khó chứa cho gọn.

using System;

class InsufficientFundsException : Exception
{
    public decimal Balance { get; }
    public decimal Requested { get; }

    public InsufficientFundsException() { }

    public InsufficientFundsException(string message) : base(message) { }

    public InsufficientFundsException(string message, Exception inner) : base(message, inner) { }

    public InsufficientFundsException(decimal balance, decimal requested)
        : base("Cannot withdraw " + requested + " from a balance of " + balance + ".")
    {
        Balance = balance;
        Requested = requested;
    }
}

class Program
{
    static decimal balance = 40m;

    static void Withdraw(decimal amount)
    {
        if (amount > balance) throw new InsufficientFundsException(balance, amount);
        balance -= amount;
    }

    static void Main()
    {
        try
        {
            Withdraw(25m);
            Withdraw(25m);
        }
        catch (InsufficientFundsException e)
        {
            Console.WriteLine(e.Message);
            Console.WriteLine("Short by " + (e.Requested - e.Balance));
        }
    }
}

Đầu ra:

Cannot withdraw 25 from a balance of 15.
Short by 10

Các quy ước:

• Tên kết thúc bằng Exception.
• Lớp kế thừa từ Exception (hoặc từ một kiểu có sẵn cụ thể hơn khi nó là trường hợp đặc biệt của kiểu đó, chẳng hạn InvalidOperationException).
• Có ba hàm khởi tạo chuẩn: không tham số, nhận thông báo, và nhận thông báo cùng inner exception. Bạn có thể thêm hàm khởi tạo riêng bên cạnh.
• Dữ liệu thêm nằm trong các thuộc tính chỉ đọc, được gán trong hàm khởi tạo. Nhờ đó trình xử lý có thể dựa vào e.Requested thay vì phải phân tích chuỗi thông báo.

Bọc ngoại lệ bằng inner exception

Khi một lỗi ở tầng thấp cần hiện ra như một lỗi ở tầng cao hơn, hãy bọc nó lại. Ngoại lệ gốc được giữ trong InnerException, nên không mất thông tin nào:

using System;

class ConfigException : Exception
{
    public ConfigException(string message, Exception inner) : base(message, inner) { }
}

class Program
{
    static int ReadPort(string text)
    {
        try
        {
            return int.Parse(text);
        }
        catch (FormatException e)
        {
            throw new ConfigException("Setting 'port' must be a number, got '" + text + "'.", e);
        }
    }

    static void Main()
    {
        try
        {
            ReadPort("80a");
        }
        catch (ConfigException e)
        {
            Console.WriteLine(e.Message);
            Console.WriteLine("Caused by: " + e.InnerException.GetType().Name);
        }
    }
}

Đầu ra:

Setting 'port' must be a number, got '80a'.
Caused by: FormatException

Giờ nơi gọi làm việc với khái niệm cấu hình, thứ nó hiểu được, còn khi ghi log e.ToString() sẽ in ra cả chuỗi lỗi, bao gồm FormatException và stack trace của nó. Chỉ bọc khi bạn thêm được ý nghĩa; bọc mọi ngoại lệ trong một MyAppException chung chung chỉ khiến trình xử lý phải đào bới InnerException.

Ném ngoại lệ hay trả về kết quả

Ngoại lệ dành cho những lỗi mà nơi gọi không lường trước trong lúc chạy bình thường. Với những kết quả thường gặp, như một lần tra cứu hay không tìm thấy gì hoặc dữ liệu người dùng nhập hay sai, quy ước của .NET là Try pattern: trả về bool và đưa giá trị ra qua một tham số out.

public bool TryWithdraw(decimal amount, out string error)
{
    if (amount > Balance) { error = "Insufficient funds."; return false; }
    Balance -= amount;
    error = null;
    return true;
}

Nhiều kiểu có cả hai: int.Parse ném ngoại lệ, int.TryParse trả về false; dict[key] ném ngoại lệ, dict.TryGetValue trả về false. Ném một ngoại lệ tốn hơn nhiều so với trả về một giá trị, nên đừng đặt nó trên một đường chạy hàng nghìn lần mỗi giây. Xem ref và out để biết về tham số out.

Viết thông báo lỗi tốt

Thông báo của ngoại lệ là thứ lập trình viên đọc khi xem log. Hãy nói rõ điều gì sai và, khi an toàn, giá trị gây lỗi: "Quantity must be between 1 and 99, got 0." tốt hơn "Invalid input." Viết thành câu đầy đủ, và đừng để bí mật như mật khẩu hay token lọt vào thông báo, vì chúng sẽ nằm lại trong tệp log.

Lỗi thường gặp

• Ném chính Exception. Nơi gọi không thể bắt riêng nó; hãy dùng một kiểu cụ thể.
• Truyền thông báo vào chỗ của tên tham số. new ArgumentNullException("name") nhận tên tham số; thông báo là đối số thứ hai.
• Viết cứng tên tham số. Dùng nameof(param) để tên luôn đúng khi đổi tên.
• Ngoại lệ tự tạo không mang thêm ý nghĩa gì. Nếu một kiểu có sẵn phù hợp, hãy dùng nó.
• Làm mất lỗi gốc khi bọc. Luôn truyền nó vào làm inner exception.