C# try catch：用 catch、when 和 finally 处理异常

当运行时出了问题（文件不存在、文本不是数字、字典里没有某个键），.NET 会抛出一个异常：一个描述错误的对象。异常会沿着调用栈向上传递，直到某个 catch 块处理它。如果没有任何地方处理，程序就会停止并打印错误。

基本的 try catch

把可能失败的代码包在 try 中，在 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");
    }
}

输出：

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

当 int.Parse("forty-two") 抛出异常时，try 块中它后面的 Console.WriteLine 会被跳过，catch (FormatException) 块运行，然后循环继续。如果不需要异常对象，可以省略变量（catch (FormatException)）。

这个特定的场景有更好的工具：int.TryParse(input, out int n) 会返回 false 而不是抛出异常。异常是为代码预料不到的情况准备的；经常无效的输入是意料之中的，所以应该检查它，而不是去捕获异常。

异常如何传递

在调用链深处抛出的异常，会逐层展开每个方法，直到找到匹配的处理程序。这些方法中位于抛出点之后的代码都不会运行。

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

输出：

OrderTotal finished
5.00
Caught KeyNotFoundException in Main

PriceOf 和 OrderTotal 都没有 catch，所以异常直接穿过它们到达 Main。把处理程序放在知道如何应对这个失败的那一层，而那往往不是出错的地方。

按正确的顺序捕获特定异常

一个 catch 子句会处理它声明的类型，以及从该类型派生的所有类型。有多个子句时，第一个匹配的子句胜出，所以要按从最具体到最笼统的顺序排列：

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

输出：

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

最后一次调用抛出了 OverflowException，前面两个具体的子句都不处理它，于是由笼统的 catch (Exception e) 处理。如果把 catch (Exception) 放在最前面，后面的子句就永远执行不到，编译器会报错 CS0160 并拒绝编译。

用 when 的异常过滤器

C# 6 新增了 when：一个决定 catch 子句是否适用的条件。如果条件为 false，运行时会继续寻找其他处理程序，就像这个子句不存在一样。

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

输出：

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

过滤器让你可以根据异常内部的数据来分支，而不必先捕获再重新抛出。它们也是用同样方式处理两个不相关类型的简洁写法，第三个子句就是这样做的。过滤器在调用栈展开之前运行，所以当没有过滤器匹配时，调试器或崩溃转储看到的仍然是原始状态。

finally：总会运行的代码

当控制流离开 try 时，无论它是正常结束、提前返回还是抛出了异常，finally 块都会运行。清理代码就放在这里。（有一个例外：如果任何地方都没有捕获这个异常，进程可能会在它运行之前就结束。）

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

输出：

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

在每种情况下，“Close connection”都会在方法的结果到达 Main 之前打印出来：finally 在 return 的值计算出来之后、方法真正返回之前运行。try 可以只带 finally 而完全没有 catch，这样既能清理资源，又能让异常继续传给调用方。

对于实现了 IDisposable 的对象（文件、流、连接），using 语句会替你写好这个 try/finally。

重新抛出：throw; 与 throw e;

有时 catch 块会记录日志或保存一些信息，然后让异常继续传递。你重新抛出的方式决定了堆栈跟踪能否保留下来：

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

输出：

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

throw e; 会把这个异常当作是从 catch 块新抛出的，所以它下面的调用帧，包括真正出错的那个方法，都会从跟踪信息中消失。重新抛出时一定要用单独的 throw;。（这里加上 NoInlining 特性，只是因为 JIT 可能会把这么小的方法合并进调用方，那样它在两种跟踪信息中都看不到。）

如果想补充上下文，就把异常包装进一个新异常，并把原始异常作为内部异常传进去：throw new ConfigException("Could not start the app", e);。内部异常会保留它自己的堆栈跟踪，日志工具会把整条链打印出来。编写自己的异常类型请参阅 抛出异常。

Exception 对象

每个异常都派生自 System.Exception。最常用的成员：

如果你想事后诊断失败，请记录 e.ToString() 而不是 e.Message：单凭消息很少能看出问题出在哪里。不要把 e.ToString() 显示给最终用户。

常见的异常类型

NullReferenceException、IndexOutOfRangeException 和 InvalidCastException 几乎总是意味着有 bug。请修复代码，而不是捕获它们。

不要吞掉异常

空的 catch 会隐藏所有错误，包括那些你没有预料到的：

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

程序会继续运行，就好像保存成功了一样，而真正的原因却丢失了。下面这些准则能让异常处理保持诚实：

• 只捕获你能处理的异常，并且在能处理它的那一层捕获。
• 如果捕获只是为了记录日志，就用 throw; 重新抛出，除非程序确实能继续运行。
• 只在最外层捕获 Exception：Main、请求处理程序、工作循环。
• 对于意料之中的情况，优先使用 TryParse、TryGetValue 和 null 检查，而不是异常。与一次检查相比，抛出异常很慢，而一个什么都没抛出的 try 块几乎没有开销。

常见错误

• 把 catch (Exception) 放在最前面。 后面的子句会变得无法执行到（CS0160）。
• 用 throw e; 重新抛出。 它会抹掉原始的堆栈跟踪；请使用 throw;。
• 空的 catch 块。 错误会凭空消失；至少要记录日志并重新抛出。
• 用异常来控制流程。 用 TryParse 验证输入，而不是去捕获 FormatException。
• 把框架异常的 e.Message 显示给用户。 它的措辞在不同 .NET 版本之间并不相同，而且是写给开发者看的。