try catch trong C#: xử lý ngoại lệ với catch, when và finally

Khi có gì đó sai lúc chạy (một tệp bị thiếu, một đoạn văn bản không phải số, một khóa không có trong dictionary), .NET ném ra một ngoại lệ (exception): một đối tượng mô tả lỗi. Ngoại lệ đi ngược lên call stack cho tới khi một khối catch xử lý nó. Nếu không có khối nào, chương trình dừng lại và in ra lỗi.

try catch cơ bản

Bọc phần code có thể gặp lỗi trong try, và xử lý lỗi trong catch:

using System;

class Program
{
    static void Main()
    {
        string[] inputs = { "42", "forty-two", "7" };

        foreach (string input in inputs)
        {
            try
            {
                int n = int.Parse(input);
                Console.WriteLine(input + " doubled is " + (n * 2));
            }
            catch (FormatException)
            {
                Console.WriteLine("'" + input + "' is not a number");
            }
        }
        Console.WriteLine("Still running");
    }
}

Đầu ra:

42 doubled is 84
'forty-two' is not a number
7 doubled is 14
Still running

Khi int.Parse("forty-two") ném ngoại lệ, câu lệnh Console.WriteLine phía sau trong khối try bị bỏ qua, khối catch (FormatException) chạy, và vòng lặp tiếp tục. Bạn có thể bỏ biến (catch (FormatException)) khi không cần đến đối tượng ngoại lệ.

Riêng trường hợp này có công cụ tốt hơn: int.TryParse(input, out int n) trả về false thay vì ném ngoại lệ. Ngoại lệ dành cho những tình huống code không lường trước; đầu vào thường xuyên sai là chuyện đã lường trước, nên hãy kiểm tra nó thay vì bắt lỗi.

Ngoại lệ đi qua các phương thức thế nào

Một ngoại lệ được ném ở sâu trong chuỗi lời gọi sẽ tháo dần từng phương thức cho tới khi gặp trình xử lý phù hợp. Code phía sau lệnh ném trong mỗi phương thức đó không được chạy.

using System;
using System.Collections.Generic;

class Program
{
    static Dictionary<string, decimal> prices = new Dictionary<string, decimal>
    {
        ["tea"] = 2.50m,
    };

    static decimal PriceOf(string item)
    {
        return prices[item];                         // throws for a missing item
    }

    static decimal OrderTotal(string item, int qty)
    {
        decimal total = PriceOf(item) * qty;
        Console.WriteLine("OrderTotal finished");    // skipped when PriceOf throws
        return total;
    }

    static void Main()
    {
        try
        {
            Console.WriteLine(OrderTotal("tea", 2));
            Console.WriteLine(OrderTotal("cake", 1));
            Console.WriteLine("not reached");
        }
        catch (KeyNotFoundException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name + " in Main");
        }
    }
}

Đầu ra:

OrderTotal finished
5.00
Caught KeyNotFoundException in Main

PriceOf và OrderTotal không có catch, nên ngoại lệ đi thẳng qua chúng tới Main. Hãy đặt trình xử lý ở tầng biết phải làm gì với lỗi đó, mà tầng này thường không phải là nơi lỗi xảy ra.

Bắt từng ngoại lệ cụ thể, theo đúng thứ tự

Một mệnh đề catch xử lý kiểu của nó và mọi kiểu kế thừa từ kiểu đó. Khi có nhiều mệnh đề, mệnh đề khớp đầu tiên sẽ thắng, nên hãy sắp xếp chúng từ cụ thể nhất đến chung nhất:

using System;

class Program
{
    static void Divide(string a, string b)
    {
        try
        {
            int x = int.Parse(a);
            int y = int.Parse(b);
            Console.WriteLine(a + " / " + b + " = " + (x / y));
        }
        catch (DivideByZeroException)
        {
            Console.WriteLine("Cannot divide by zero");
        }
        catch (FormatException)
        {
            Console.WriteLine("Both values must be whole numbers");
        }
        catch (Exception e)
        {
            Console.WriteLine("Unexpected: " + e.GetType().Name);
        }
    }

    static void Main()
    {
        Divide("10", "2");
        Divide("10", "0");
        Divide("ten", "2");
        Divide("99999999999", "1"); // too large for int
    }
}

Đầu ra:

10 / 2 = 5
Cannot divide by zero
Both values must be whole numbers
Unexpected: OverflowException

Lời gọi cuối cùng ném OverflowException, không mệnh đề cụ thể nào xử lý nó, nên catch (Exception e) chung sẽ nhận. Đặt catch (Exception) lên đầu sẽ khiến các mệnh đề phía sau không bao giờ tới được, và trình biên dịch từ chối điều đó bằng lỗi CS0160.

Exception filter với when

C# 6 thêm when: một điều kiện quyết định mệnh đề catch có áp dụng hay không. Nếu điều kiện là false, runtime tiếp tục tìm trình xử lý khác như thể mệnh đề đó không tồn tại.

using System;

class ApiException : Exception
{
    public int StatusCode { get; }
    public ApiException(int statusCode) : base("HTTP " + statusCode)
    {
        StatusCode = statusCode;
    }
}

class Program
{
    static void Call(int status)
    {
        try
        {
            throw new ApiException(status);
        }
        catch (ApiException e) when (e.StatusCode == 404)
        {
            Console.WriteLine("Not found: show an empty page");
        }
        catch (ApiException e) when (e.StatusCode >= 500)
        {
            Console.WriteLine("Server error " + e.StatusCode + ": retry later");
        }
        catch (Exception e) when (e is ArgumentException || e is FormatException)
        {
            Console.WriteLine("Bad input");
        }
    }

    static void Main()
    {
        Call(404);
        Call(503);
        try
        {
            Call(401); // no clause matches: it propagates
        }
        catch (ApiException e)
        {
            Console.WriteLine("Unhandled by Call: " + e.Message);
        }
    }
}

Đầu ra:

Not found: show an empty page
Server error 503: retry later
Unhandled by Call: HTTP 401

Bộ lọc cho phép bạn rẽ nhánh theo dữ liệu bên trong ngoại lệ mà không cần bắt rồi ném lại. Đây cũng là cách gọn gàng để xử lý hai kiểu không liên quan theo cùng một cách, như mệnh đề thứ ba. Bộ lọc chạy trước khi stack bị tháo, nên khi không có bộ lọc nào khớp, debugger hoặc crash dump vẫn thấy được trạng thái ban đầu.

finally: code luôn được chạy

Khối finally chạy khi luồng điều khiển rời khỏi try, dù nó chạy xong, trả về sớm hay ném ngoại lệ. Đây là chỗ để dọn dẹp. (Có một lưu ý: nếu không ở đâu bắt ngoại lệ, tiến trình có thể kết thúc mà không chạy khối này.)

using System;

class Program
{
    static string Process(int step)
    {
        Console.WriteLine("Open connection");
        try
        {
            if (step == 1) return "returned early";
            if (step == 2) throw new InvalidOperationException();
            return "finished";
        }
        catch (InvalidOperationException)
        {
            return "handled error";
        }
        finally
        {
            Console.WriteLine("Close connection");
        }
    }

    static void Main()
    {
        Console.WriteLine(Process(0));
        Console.WriteLine(Process(1));
        Console.WriteLine(Process(2));
    }
}

Đầu ra:

Open connection
Close connection
finished
Open connection
Close connection
returned early
Open connection
Close connection
handled error

Trong mọi trường hợp, "Close connection" đều được in ra trước khi kết quả của phương thức tới được Main: finally chạy sau khi giá trị của return đã được tính nhưng trước khi phương thức thật sự trả về. Một try có thể có finally mà không cần catch nào, để dọn dẹp trong khi vẫn để ngoại lệ tiếp tục đi tới nơi gọi.

Với các đối tượng cài đặt IDisposable (tệp, stream, kết nối), câu lệnh using sẽ viết sẵn cặp try/finally này cho bạn.

Ném lại: throw; và throw e;

Đôi khi một khối catch ghi log hoặc lưu lại điều gì đó rồi để ngoại lệ đi tiếp. Cách bạn ném lại quyết định stack trace có còn nguyên hay không:

using System;
using System.Runtime.CompilerServices;

class Program
{
    // NoInlining keeps this small method as its own frame in the stack trace.
    [MethodImpl(MethodImplOptions.NoInlining)]
    static void LoadConfig()
    {
        throw new InvalidOperationException("config file missing");
    }

    static void RethrowKeep()
    {
        try { LoadConfig(); }
        catch (InvalidOperationException) { throw; }      // original trace
    }

    static void RethrowReset()
    {
        try { LoadConfig(); }
        catch (InvalidOperationException e) { throw e; }  // trace restarts here
    }

    static void Main()
    {
        try { RethrowKeep(); }
        catch (Exception e)
        {
            Console.WriteLine("throw;   trace mentions LoadConfig: " + e.StackTrace.Contains("LoadConfig"));
        }

        try { RethrowReset(); }
        catch (Exception e)
        {
            Console.WriteLine("throw e; trace mentions LoadConfig: " + e.StackTrace.Contains("LoadConfig"));
        }
    }
}

Đầu ra:

throw;   trace mentions LoadConfig: True
throw e; trace mentions LoadConfig: False

throw e; coi ngoại lệ như vừa được ném từ khối catch, nên các frame bên dưới, kể cả phương thức nơi lỗi xảy ra, biến mất khỏi trace. Luôn ném lại bằng throw; trơn. (Thuộc tính NoInlining có mặt chỉ vì JIT có thể gộp một phương thức nhỏ như vậy vào nơi gọi nó, khiến nó biến mất khỏi cả hai trace.)

Nếu muốn thêm ngữ cảnh, hãy bọc ngoại lệ trong một ngoại lệ mới và truyền ngoại lệ gốc vào làm inner exception: throw new ConfigException("Could not start the app", e);. Inner exception giữ stack trace riêng của nó, và các trình ghi log sẽ in ra cả chuỗi. Cách viết kiểu ngoại lệ của riêng bạn có ở trang ném ngoại lệ.

Đối tượng Exception

Mọi ngoại lệ đều kế thừa từ System.Exception. Các thành viên bạn dùng nhiều nhất:

Hãy ghi log e.ToString() thay vì e.Message khi bạn muốn chẩn đoán lỗi về sau: riêng thông báo hiếm khi cho biết vấn đề nằm ở đâu. Đừng hiển thị e.ToString() cho người dùng cuối.

Các kiểu ngoại lệ thường gặp

NullReferenceException, IndexOutOfRangeException và InvalidCastException gần như luôn có nghĩa là có bug. Hãy sửa code thay vì bắt chúng.

Đừng nuốt ngoại lệ

Một khối catch rỗng che giấu mọi lỗi, kể cả những lỗi bạn không lường trước:

try
{
    SaveOrder(order);
}
catch (Exception)
{
    // nothing: the order silently was not saved
}

Chương trình tiếp tục chạy như thể việc lưu đã thành công, và nguyên nhân thật bị mất. Vài nguyên tắc giúp việc xử lý ngoại lệ minh bạch:

• Chỉ bắt những gì bạn xử lý được, ở tầng có thể xử lý nó.
• Nếu bắt để ghi log, hãy ném lại bằng throw; trừ khi chương trình thật sự chạy tiếp được.
• Chỉ bắt Exception ở rìa ngoài cùng: Main, một trình xử lý request, một vòng lặp worker.
• Với những trường hợp đã lường trước, hãy ưu tiên TryParse, TryGetValue và kiểm tra null thay vì ngoại lệ. Ném ngoại lệ chậm hơn nhiều so với một phép kiểm tra, còn một khối try không ném gì thì gần như không tốn chi phí.

Lỗi thường gặp

• Đặt catch (Exception) lên đầu. Các mệnh đề phía sau không bao giờ tới được (CS0160).
• Dùng throw e; để ném lại. Nó xóa stack trace gốc; hãy dùng throw;.
• Khối catch rỗng. Lỗi biến mất; ít nhất hãy ghi log rồi ném lại.
• Dùng ngoại lệ để điều khiển luồng chạy. Kiểm tra đầu vào bằng TryParse thay vì bắt FormatException.
• Hiển thị e.Message của ngoại lệ từ framework cho người dùng. Câu chữ khác nhau giữa các phiên bản .NET và được viết cho lập trình viên.