The string returned from StackTrace documents the sequence of calls that resulted in the throwing of this exception. Notice how the bottommost line number of this string identifies the first call in the
sequence, while the topmost line number identifies the exact location of the offending member. Clearly, this information can be quite helpful during the debugging or logging of a given application, as you are able to “follow the flow” of the error’s origin.
从 StackTrace 返回的字符串记录了导致引发此异常的调用序列。请注意此字符串最底部的行号如何标识序列，而最上面的行号标识违规成员的确切位置。显然，在调试或记录给定应用程序期间，此信息非常有用，因为您可以“跟踪错误来源的流程”。

The HelpLink Property

帮助链接属性

While the TargetSite and StackTrace properties allow programmers to gain an understanding of a given exception, this information is of little use to the end user. As you have already seen, the System.Exception. Message property can be used to obtain human-readable information that can be displayed to the current user. In addition, the HelpLink property can be set to point the user to a specific URL or standard help file that contains more detailed information.
虽然 TargetSite 和 StackTrace 属性允许程序员了解给定的异常，但此信息对最终用户几乎没有用处。正如您已经看到的，System.Exception。消息属性可用于获取可显示给当前用户的人类可读信息。此外，还可以将 HelpLink 属性设置为将用户指向包含更多详细信息的特定 URL 或标准帮助文件。

By default, the value managed by the HelpLink property is an empty string. Update the exception using object initialization to provide a more interesting value. Here are the relevant updates to the Car. Accelerate() method:
默认情况下，由帮助链接属性管理的值为空字符串。使用对象初始化更新异常以提供更有趣的值。以下是汽车的相关更新。加速（） 方法：

public void Accelerate(int delta)
{
if (_carIsDead)
{
Console.WriteLine("{0} is out of order…", PetName);
}
else
{
CurrentSpeed += delta;
if (CurrentSpeed >= MaxSpeed)
{
CurrentSpeed = 0;
_carIsDead = true;

// Use the "throw" keyword to raise an exception and
// return to the caller.
throw new Exception($"{PetName} has overheated!")
{
HelpLink = "http://www.CarsRUs.com"
};
}
Console.WriteLine("=> CurrentSpeed = {0}", CurrentSpeed);
}
}

The catch logic could now be updated to print this help-link information as follows:

catch(Exception e)
{
…
Console.WriteLine("Help Link: {0}", e.HelpLink);
}

The Data Property

数据属性

The Data property of System.Exception allows you to fill an exception object with relevant auxiliary information (such as a timestamp). The Data property returns an object implementing an interface named IDictionary, defined in the System.Collections namespace. Chapter 8 examines the role of interface- based programming, as well as the System.Collections namespace. For the time being, just understand that dictionary collections allow you to create a set of values that are retrieved using a specific key. Observe the next update to the Car.Accelerate() method:
System.Exception 的 Data 属性允许您使用相关的辅助信息（如时间戳）填充异常对象。Data 属性返回一个对象，该对象实现在 System.Collections 命名空间中定义的名为 IDictionary 的接口。第8章探讨了基于接口的编程以及System.Collections命名空间的作用。目前，只需了解字典集合允许您创建一组使用特定键检索的值。观察 Car.Accelerate（） 方法的下一次更新：

public void Accelerate(int delta)
{
if (_carIsDead)
{
Console.WriteLine("{0} is out of order…", PetName);
}
else
{
CurrentSpeed += delta;
if (CurrentSpeed >= MaxSpeed)
{
Console.WriteLine("{0} has overheated!", PetName); CurrentSpeed = 0;
_carIsDead = true;
// Use the "throw" keyword to raise an exception
// and return to the caller.
throw new Exception($"{PetName} has overheated!")
{
HelpLink = "http://www.CarsRUs.com", Data = {
{"TimeStamp",$"The car exploded at {DateTime.Now}"},
{"Cause","You have a lead foot."}
}

};
}
Console.WriteLine("=> CurrentSpeed = {0}", CurrentSpeed);
}
}

To successfully enumerate over the key-value pairs, make sure you added a using directive for the System.Collections namespace since you will use a DictionaryEntry type in the file containing the class implementing your top-level statements.
若要成功枚举键值对，请确保为 System.Collections 命名空间添加了 using 指令，因为您将在包含实现顶级语句的类的文件中使用 DictionaryEntry 类型。

using System.Collections;

Next, you need to update the catch logic to test that the value returned from the Data property is not null (the default value). After that, you use the Key and Value properties of the DictionaryEntry type to print the custom data to the console.
接下来，需要更新 catch 逻辑以测试从 Data 属性返回的值是否不为 null（默认值）。之后，您可以使用 DictionaryEntry 类型的键和值属性将自定义数据打印到控制台。

catch (Exception e)
{
…
Console.WriteLine("\n-> Custom Data:"); foreach (DictionaryEntry de in e.Data)
{
Console.WriteLine("-> {0}: {1}", de.Key, de.Value);
}
}

With this, here’s the final output you’d see:
有了这个，这是您将看到的最终输出：

Simple Exception Example
=> Creating a car and stepping on it! Jamming…
=> CurrentSpeed = 30
=> CurrentSpeed = 40
=> CurrentSpeed = 50
=> CurrentSpeed = 60
=> CurrentSpeed = 70
=> CurrentSpeed = 80
=> CurrentSpeed = 90
Error!
Member name: Void Accelerate(Int32)
Class defining member: SimpleException.Car Member type: Method
Message: Zippy has overheated! Source: SimpleException
Stack: at SimpleException.Car.Accelerate(Int32 delta) … at SimpleException.Program.Main(String[] args) …
Help Link: http://www.CarsRUs.com

-> Custom Data:
-> TimeStamp: The car exploded at 3/15/2020 16:22:59
-> Cause: You have a lead foot.

Out of exception logic

The Data property is useful in that it allows you to pack in custom information regarding the error at hand, without requiring the building of a new class type to extend the Exception base class. As helpful as the Data property may be, however, it is still common for developers to build strongly typed exception classes, which handle custom data using strongly typed properties.
Data 属性非常有用，因为它允许您打包有关当前错误的自定义信息，而无需生成新的类类型来扩展 Exception 基类。但是，尽管 Data 属性可能很有帮助，但开发人员仍然很常见地生成强类型异常类，这些异常类使用强类型属性处理自定义数据。

This approach allows the caller to catch a specific exception-derived type, rather than having to dig into a data collection to obtain additional details. To understand how to do this, you need to examine the distinction between system-level and application-level exceptions.
Data 属性非常有用，因为它允许您打包有关当前错误的自定义信息，而无需生成新的类类型来扩展 Exception 基类。但是，尽管 Data 属性可能很有帮助，但开发人员仍然很常见地生成强类型异常类，这些异常类使用强类型属性处理自定义数据。

System-Level Exceptions (System.SystemException)

系统级异常（System.SystemException）

The .NET base class libraries define many classes that ultimately derive from System.Exception. For example, the System namespace defines core exception objects such as ArgumentOutOfRangeException, IndexOutOfRangeException, StackOverflowException, and so forth. Other namespaces define exceptions that reflect the behavior of that namespace. For example, System.Drawing.Printing defines printing exceptions, System.IO defines input/output-based exceptions, System.Data defines database-centric exceptions, and so forth.
.NET 基类库定义了许多最终派生自 System.Exception 的类。例如，命名空间定义核心异常对象，如 ArgumentOutOfRangeException、IndexOutOfRangeException、StackOverflowException 等。其他命名空间定义反映该命名空间行为的异常。例如，System.Drawing.Print 定义打印异常，System.IO 定义基于输入/输出的异常，System.Data 定义以数据库为中心的异常，等等。

Exceptions that are thrown by the .NET platform are (appropriately) called system exceptions. These exceptions are generally regarded as nonrecoverable, fatal errors. System exceptions derive directly from a base class named System.SystemException, which in turn derives from System.Exception (which derives from System.Object).
.NET 平台引发的异常（适当地）称为系统异常。这些异常通常被视为不可恢复的致命错误。系统异常直接派生自名为 System.SystemException 的基类，而基类又派生自 System.Exception（派生自 System.Object）。

public class SystemException : Exception
{
// Various constructors.
}

Given that the System.SystemException type does not add any functionality beyond a set of custom constructors, you might wonder why SystemException exists in the first place. Simply put, when an exception type derives from System.SystemException, you are able to determine that the .NET runtime is the entity that has thrown the exception, rather than the code base of the executing application. You can verify this quite simply using the is keyword.
鉴于 System.SystemException 类型除了一组自定义构造函数之外不会添加任何功能，您可能想知道为什么 SystemException 首先存在。简而言之，当异常类型派生自 System.SystemException 时，您可以确定 .NET 运行时是引发异常的实体，而不是正在执行的应用程序的代码库。您可以使用 is 关键字非常简单地验证这一点。

// True! NullReferenceException is-a SystemException. NullReferenceException nullRefEx = new NullReferenceException(); Console.WriteLine(
"NullReferenceException is-a SystemException? : {0}", nullRefEx is SystemException);

Application-Level Exceptions (System.ApplicationException)

应用程序级异常（System.ApplicationException）

Given that all .NET exceptions are class types, you are free to create your own application-specific exceptions. However, because the System.SystemException base class represents exceptions thrown from the runtime, you might naturally assume that you should derive your custom exceptions from the System.Exception type. You could do this, but you could instead derive from the System. ApplicationException class.
鉴于所有 .NET 异常都是类类型，您可以自由创建自己的特定于应用程序的异常。但是，由于 System.SystemException 基类表示从运行时引发的异常，因此您可能自然而然地假定应派生自定义异常从系统异常类型。您可以这样做，但您可以从系统派生。应用程序异常类。

public class ApplicationException : Exception
{
// Various constructors.
}

Like SystemException, ApplicationException does not define any additional members beyond a set of constructors. Functionally, the only purpose of System.ApplicationException is to identify the source of the error. When you handle an exception deriving from System.ApplicationException, you can assume the exception was raised by the code base of the executing application, rather than by the .NET Core base class libraries or .NET runtime engine.
与 SystemException 一样，ApplicationException 除了一组构造函数之外，不会定义任何其他成员。从功能上讲，System.ApplicationException 的唯一目的是识别错误的源。处理从 System.ApplicationException 派生的异常时，可以假定异常是由执行应用程序的代码库引发的，而不是由 .NET Core 基类库或 .NET 运行时引擎引发的。

Building Custom Exceptions, Take 1

构建自定义异常，采用 1

While you can always throw instances of System.Exception to signal a runtime error (as shown in the first example), it is sometimes advantageous to build a strongly typed exception that represents the unique details of your current problem. For example, assume you want to build a custom exception (named CarIsDeadException) to represent the error of speeding up a doomed automobile. The first step is to derive a new class from System.Exception/System.ApplicationException (by convention, all exception class names end with the Exception suffix).
虽然您始终可以抛出 System.Exception 的实例来发出运行时错误的信号（如第一个示例中所示），但有时构建一个表示当前问题的唯一详细信息的强类型异常是有利的。例如，假设您要构建一个自定义异常（名为CarIsDeadException）来表示加速注定要失败的汽车的错误。第一步是从 System.Exception/System.ApplicationException 派生一个新类（按照惯例，所有异常类名都以 Exception 后缀结尾）。

■ Note as a rule, all custom exception classes should be defined as public classes (recall that the default access modifier of a non-nested type is internal). The reason is that exceptions are often passed outside of assembly boundaries and should therefore be accessible to the calling code base.
请注意，作为一项规则，所有自定义异常类都应定义为公共类（回想一下，非嵌套类型的默认访问修饰符是内部的）。原因是异常通常在程序集边界之外传递，因此调用代码库应该可以访问。

Create a new Console Application project named CustomException, copy the previous Car.cs and Radio.cs files into your new project, and change the namespace that defines the Car and Radio types from SimpleException to CustomException. Next, add a new file named CarIsDeadException.cs and add the following class definition:
创建一个名为 CustomException 的新控制台应用程序项目，将以前的 Car.cs 和 Radio.cs 文件复制到新项目中，并将定义 Car 和 Radio 类型的命名空间从 SimpleException 更改为 CustomException。接下来，添加一个名为 CarIsDeadException 的新文件.cs并添加以下类定义：

namespace CustomException;
// This custom exception describes the details of the car-is-dead condition.
// (Remember, you can also simply extend Exception.) public class CarIsDeadException : ApplicationException
{
}

As with any class, you are free to include any number of custom members that can be called within the catch block of the calling logic. You are also free to override any virtual members defined by your parent classes. For example, you could implement CarIsDeadException by overriding the virtual Message property.
与任何类一样，您可以自由地包含任意数量的自定义成员，这些成员可以在调用逻辑的 catch 块中调用。您还可以自由覆盖父类定义的任何虚拟成员。例如，您可以通过重写虚拟消息属性来实现 CarIsDeadException。

As well, rather than populating a data dictionary (via the Data property) when throwing the exception, the constructor allows the sender to pass in a timestamp and reason for the error. Finally, the timestamp data and cause of the error can be obtained using strongly typed properties.
同样，构造函数允许发送方传入时间戳和错误原因，而不是在引发异常时填充数据字典（通过 Data 属性）。最后，可以使用强类型属性获取时间戳数据和错误原因。

public class CarIsDeadException : ApplicationException
{
private string _messageDetails = String.Empty; public DateTime ErrorTimeStamp {get; set;} public string CauseOfError {get; set;}

public CarIsDeadException(){}
public CarIsDeadException(string message, string cause, DateTime time)
{
_messageDetails = message; CauseOfError = cause; ErrorTimeStamp = time;
}

// Override the Exception.Message property. public override string Message
=> $"Car Error Message: {_messageDetails}";
}

Here, the CarIsDeadException class maintains a private field (_messageDetails) that represents data regarding the current exception, which can be set using a custom constructor. Throwing this exception from the Accelerate() method is straightforward. Simply allocate, configure, and throw a CarIsDeadException type rather than a System.Exception.
在这里，CarIsDeadException 类维护一个私有字段 （_messageDetails），该字段表示有关当前异常的数据，可以使用自定义构造函数进行设置。从 Accelerate（） 方法引发此异常非常简单。只需分配、配置和抛出 CarIsDeadException 类型，而不是 System.Exception。

// Throw the custom CarIsDeadException. public void Accelerate(int delta)
{
…
throw new CarIsDeadException(
$"{PetName} has overheated!",
"You have a lead foot", DateTime.Now )
{
HelpLink = "http://www.CarsRUs.com",
};
…
}

To catch this incoming exception, your catch scope can now be updated to catch a specific CarIsDeadException type (however, given that CarIsDeadException “is-a” System.Exception, it is still permissible to catch a System.Exception as well).
要捕获此传入异常，现在可以更新捕获范围以捕获特定的CarIsDeadException类型（但是，鉴于CarIsDeadException“是-a”System.Exception，仍然允许捕获System.Exception）。

using CustomException;

Console.WriteLine(" Fun with Custom Exceptions \n"); Car myCar = new Car("Rusty", 90);

try
{
// Trip exception. myCar.Accelerate(50);
}
catch (CarIsDeadException e)

{
Console.WriteLine(e.Message); Console.WriteLine(e.ErrorTimeStamp); Console.WriteLine(e.CauseOfError);
}
Console.ReadLine();

So, now that you understand the basic process of building a custom exception, it’s time to build on that knowledge.
因此，现在您已经了解了构建自定义异常的基本过程，是时候基于这些知识进行构建了。

Building Custom Exceptions, Take 2

构建自定义异常，采用 2

The current CarIsDeadException type has overridden the virtual System.Exception.Message property to configure a custom error message and has supplied two custom properties to account for additional bits of data. In reality, however, you are not required to override the virtual Message property, as you could simply pass the incoming message to the parent’s constructor as follows:
当前的 CarIsDeadException 类型已覆盖虚拟 System.Exception.Message 属性以配置自定义错误消息，并提供了两个自定义属性来考虑其他数据位。但是，实际上，您不需要重写虚拟 Message 属性，因为您只需将传入消息传递给父级的构造函数，如下所示：

public class CarIsDeadException : ApplicationException
{
public DateTime ErrorTimeStamp { get; set; } public string CauseOfError { get; set; }

public CarIsDeadException() { }

// Feed message to parent constructor.
public CarIsDeadException(string message, string cause, DateTime time)
:base(message)
{
CauseOfError = cause;
ErrorTimeStamp = time;
}
}

Notice that this time you have not defined a string variable to represent the message and have not overridden the Message property. Rather, you are simply passing the parameter to your base class constructor. With this design, a custom exception class is little more than a uniquely named class deriving from System. ApplicationException (with additional properties if appropriate), devoid of any base class overrides.
请注意，这次您没有定义一个字符串变量来表示消息，也没有重写 Message 属性。相反，您只需将参数传递给基类构造函数。通过这种设计，自定义异常类只不过是从 System 派生的唯一命名类。ApplicationException（如果适用，具有其他属性），没有任何基类重写。

Don’t be surprised if most (if not all) of your custom exception classes follow this simple pattern. Many times, the role of a custom exception is not necessarily to provide additional functionality beyond what is inherited from the base classes but to supply a strongly named type that clearly identifies the nature of the error so the client can provide different handler logic for different types of exceptions.
如果大多数（如果不是全部）自定义异常类都遵循这种简单的模式，请不要感到惊讶。很多时候，自定义异常的作用不一定是提供从基类继承的功能之外的其他功能，而是提供明确标识错误性质的强名称类型，以便客户端可以为不同类型的异常提供不同的处理程序逻辑。

Building Custom Exceptions, Take 3

构建自定义异常，采用 3

If you want to build a truly prim-and-proper custom exception class, you want to make sure your custom exception does the following:
如果要生成一个真正原始且正确的自定义异常类，则需要确保自定义异常执行以下操作：
• Derives from Exception/ApplicationException
派生自异常/应用程序异常
• Defines a default constructor
定义默认构造函数
•Defines a constructor that sets the inherited Message property
定义设置继承的 Message 属性的构造函数
•Defines a constructor to handle “inner exceptions”
定义用于处理“内部异常”的构造函数

To complete your examination of building custom exceptions, here is the final iteration of CarIsDeadException, which accounts for each of these special constructors (the properties would be as shown in the previous example):
为了完成对生成自定义异常的检查，下面是 CarIsDeadException 的最终迭代，它考虑了这些特殊构造函数中的每一个（属性如前面的示例所示）：

public class CarIsDeadException : ApplicationException
{
private string _messageDetails = String.Empty; public DateTime ErrorTimeStamp {get; set;} public string CauseOfError {get; set;}

public CarIsDeadException(){}
public CarIsDeadException(string cause, DateTime time) : this(cause,time,string.Empty)
{
}
public CarIsDeadException(string cause, DateTime time, string message) : this(cause,time,message, null)
{
}

public CarIsDeadException(string cause, DateTime time, string message, System. Exception inner)
: base(message, inner)
{
CauseOfError = cause;
ErrorTimeStamp = time;
}
}

With this update to your custom exception, update the Accelerate() method to the following:
通过对自定义异常的此更新，将 Accelerate（） 方法更新为以下内容：

throw new CarIsDeadException("You have a lead foot", DateTime.Now,$"{PetName} has overheated!")
{
HelpLink = "http://www.CarsRUs.com",
};

Given that building custom exceptions that adhere to .NET Core best practices really differ by only their name, you will be happy to know that Visual Studio provides a code snippet template named Exception that will autogenerate a new exception class that adheres to .NET best practices. To activate it, type exc in the editor and hit the Tab key (in Visual Studio, hit the Tab key twice).
鉴于生成遵循 .NET Core 最佳做法的自定义异常实际上仅在名称上有所不同，您会很高兴知道 Visual Studio 提供了一个名为 Exception 的代码段模板，该模板将自动生成符合 .NET 最佳做法的新异常类。要激活它，请在编辑器中键入 exc 并按 Tab 键（在 Visual Studio 中，按 Tab 键两次）。

Multiple Exceptions

处理多个异常

In its simplest form, a try block has a single catch block. In reality, though, you often run into situations where the statements within a try block could trigger numerous possible exceptions. Create a new
C# Console Application project named ProcessMultipleExceptions; copy the Car.cs, Radio.cs, and CarIsDeadException.cs files from the previous CustomException example into the new project, and update your namespace names accordingly.
在最简单的形式中，try 块只有一个 catch 块。但是，在现实中，您经常会遇到 try 块中的语句可能会触发许多可能的异常的情况。创建一个新的名为 ProcessMultipleExceptions 的 C# 控制台应用程序项目;将 Car.cs、Radio.cs 和 CarIsDeadException.cs 文件从以前的 CustomException 示例复制到新项目中，并相应地更新命名空间名称。

Now, update Car’s Accelerate() method to also throw a predefined base class library ArgumentOutOfRangeException if you pass an invalid parameter (which you can assume is any value less than zero). Note the constructor of this exception class takes the name of the offending argument as the first string, followed by a message describing the error.
现在，更新 Car 的 Accelerate（） 方法，以便在传递无效参数（可以假定该参数小于零的任何值）时也抛出预定义的基类库 ArgumentOutOfRangeException。请注意，此异常类的构造函数将有问题的参数的名称作为第一个字符串，后跟描述错误的消息。

// Test for invalid argument before proceeding. public void Accelerate(int delta)
{
if (delta < 0)
{
throw new ArgumentOutOfRangeException(nameof(delta), "Speed must be greater than zero");
}
…
}

■ Note The nameof() operator returns a string representing the name of the object, in this example the variable delta. This is a safer way to refer to C# objects, methods, and variables when the string version is required.
注意 nameof（） 运算符返回一个表示对象名称的字符串，在本例中为变量 delta。当需要字符串版本时，这是引用 C# 对象、方法和变量的更安全方法。

The catch logic could now specifically respond to each type of exception.
catch 逻辑现在可以专门响应每种类型的异常。

using ProcessMultipleExceptions;

Console.WriteLine(" Handling Multiple Exceptions \n"); Car myCar = new Car("Rusty", 90);
try
{
// Trip Arg out of range exception. myCar.Accelerate(-10);
}
catch (CarIsDeadException e)
{
Console.WriteLine(e.Message);
}
catch (ArgumentOutOfRangeException e)
{
Console.WriteLine(e.Message);
}
Console.ReadLine();

When you are authoring multiple catch blocks, you must be aware that when an exception is thrown, it will be processed by the first appropriate catch. To illustrate exactly what the “first appropriate” catch means, assume you retrofitted the previous logic with an additional catch scope that attempts to handle all exceptions beyond CarIsDeadException and ArgumentOutOfRangeException by catching a general System. Exception as follows:
创作多个 catch 块时，必须注意，当引发异常时，它将由第一个适当的 catch 处理。为了准确说明“第一个适当的”捕获的含义，假设您使用尝试处理所有捕获的附加捕获范围来改造前面的逻辑CarIsDeadException 和 ArgumentOutOfRangeException 之外的异常，通过捕获一般系统。例外情况如下：

// This code will not compile!
Console.WriteLine(" Handling Multiple Exceptions \n"); Car myCar = new Car("Rusty", 90);

try
{
// Trigger an argument out of range exception. myCar.Accelerate(-10);
}
catch(Exception e)
{
// Process all other exceptions? Console.WriteLine(e.Message);
}
catch (CarIsDeadException e)
{
Console.WriteLine(e.Message);
}
catch (ArgumentOutOfRangeException e)
{
Console.WriteLine(e.Message);
}
Console.ReadLine();

This exception handling logic generates compile-time errors. The problem is that the first catch block can handle anything derived from System.Exception (given the “is-a” relationship), including the CarIsDeadException and ArgumentOutOfRangeException types. Therefore, the final two catch blocks are unreachable!
此异常处理逻辑生成编译时错误。问题在于，第一个 catch 块可以处理从 System.Exception 派生的任何内容（给定“is-a”关系），包括 CarIsDeadException 和 ArgumentOutOfRangeException 类型。因此，最后两个捕获块是无法访问的！

The rule of thumb to keep in mind is to make sure your catch blocks are structured such that the first catch is the most specific exception (i.e., the most derived type in an exception-type inheritance chain), leaving the final catch for the most general (i.e., the base class of a given exception inheritance chain, in this case System.Exception).
要记住的经验法则是确保你的 catch 块的结构使得第一个 catch 是最具体的异常（即异常类型继承链中派生最多的类型），将最终的 catch 留给最一般的（即，给定异常继承链的基类，在本例中为 System.Exception）。

Thus, if you want to define a catch block that will handle any errors beyond CarIsDeadException and
ArgumentOutOfRangeException, you could write the following:
因此，如果你想定义一个捕获块来处理CarIsDeadException之外的任何错误，并且ArgumentOutOfRangeException，你可以写以下内容：

// This code compiles just fine.
Console.WriteLine(" Handling Multiple Exceptions \n"); Car myCar = new Car("Rusty", 90);
try
{
// Trigger an argument out of range exception. myCar.Accelerate(-10);
}
catch (CarIsDeadException e)
{
Console.WriteLine(e.Message);
}
catch (ArgumentOutOfRangeException e)
{
Console.WriteLine(e.Message);
}

// This will catch any other exception
// beyond CarIsDeadException or
// ArgumentOutOfRangeException. catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.ReadLine();

■ Note Where at all possible, always favor catching specific exception classes, rather than a general System.Exception. Though it might appear to make life simple in the short term (you may think “ah! This catches all the other things I don’t care about.”), in the long term you could end up with strange runtime crashes, as a more serious error was not directly dealt with in your code. remember, a final catch block that deals with System.Exception tends to be very general indeed.
注意 在可能的情况下，始终倾向于捕获特定的异常类，而不是一般的 System.Exception。虽然它可能在短期内看起来使生活变得简单（你可能会想“啊！这抓住了我不关心的所有其他事情“），从长远来看，你最终可能会遇到奇怪的运行时崩溃，因为更严重的错误没有在你的代码中直接处理。请记住，处理System.Exception的最后一个捕获块确实非常通用。

General catch Statements

一般捕获声明

C# also supports a “general” catch scope that does not explicitly receive the exception object thrown by a given member.
C# 还支持“常规”捕获范围，该范围不显式接收给定成员引发的异常对象。

// A generic catch.
Console.WriteLine(" Handling Multiple Exceptions \n"); Car myCar = new Car("Rusty", 90);
try
{
myCar.Accelerate(90);
}
catch
{
Console.WriteLine("Something bad happened…");
}
Console.ReadLine();

Obviously, this is not the most informative way to handle exceptions since you have no way to obtain meaningful data about the error that occurred (such as the method name, call stack, or custom message). Nevertheless, C# does allow for such a construct, which can be helpful when you want to handle all errors in a general fashion.
显然，这不是处理异常的最有用的方法，因为您无法获取有关所发生错误的有意义的数据（例如方法名称、调用堆栈或自定义消息）。尽管如此，C# 确实允许这样的构造，当您希望以常规方式处理所有错误时，这会很有帮助。

Rethrowing Exceptions

重新引发异常

When you catch an exception, it is permissible for the logic in a try block to rethrow the exception up the call stack to the previous caller. To do so, simply use throw() within a catch block. This passes the exception up the chain of calling logic, which can be helpful if your catch block is only able to partially handle the error at hand.
捕获异常时，允许 try 块中的逻辑将异常重新抛出到调用堆栈中到前一个调用方。为此，只需在 catch 块中使用 throw（）。 这会将异常传递到调用逻辑链上，如果您的 catch 块只能部分处理手头的错误，这会很有帮助。

// Passing the buck.
…
try
{
// Speed up car logic…
}
catch(CarIsDeadException e)
{
// Do any partial processing of this error and pass the buck. throw;
}
…

Be aware that, in this example code, the ultimate receiver of CarIsDeadException is the .NET runtime because it is the top-level statements rethrowing the exception. Because of this, your end user is presented with a system-supplied error dialog box. Typically, you would only rethrow a partial handled exception to a caller that has the ability to handle the incoming exception more gracefully.
请注意，在此示例代码中，CarIsDeadException 的最终接收方是 .NET 运行时，因为它是重新引发异常的顶级语句。因此，最终用户会看到系统提供的错误对话框。通常，您只会将部分处理的异常重新引发给能够更优雅地处理传入异常的调用方。

Notice as well that you are not explicitly rethrowing the CarIsDeadException object but rather making use of throw() with no argument. You’re not creating a new exception object; you’re just rethrowing
the original exception object (with all its original information). Doing so preserves the context of the original target.
还要注意的是，你没有显式地重新抛出 CarIsDeadException 对象，而是在没有参数的情况下使用 throw（）。 您没有创建新的异常对象;你只是在重新投掷原始异常对象（及其所有原始信息）。这样做可以保留原始目标的上下文。

Inner Exceptions

内部异常

As you might suspect, it is entirely possible to trigger an exception at the time you are handling another exception. For example, assume you are handling a CarIsDeadException within a particular catch scope and during the process you attempt to record the stack trace to a file on your C: drive named carErrors. txt (the implicit global using statements grant you access to the System.IO namespace and its I/O- centric types).
正如您可能怀疑的那样，完全有可能在处理另一个异常时触发异常。例如，假设您正在特定的 catch 范围内处理 CarIsDeadException，并且在此过程中尝试将堆栈跟踪记录到 C： 驱动器上名为 carErrors 的文件.txt （隐式全局 using 语句授予您访问 System.IO 命名空间及其以 I/O 为中心的类型）。

catch(CarIsDeadException e)
{
// Attempt to open a file named carErrors.txt on the C drive. FileStream fs = File.Open(@"C:\carErrors.txt", FileMode.Open);
…
}

Now, if the specified file is not located on your C: drive, the call to File.Open() results in a FileNotFoundException! Later in this book, you will learn all about the System.IO namespace where you’ll discover how to programmatically determine whether a file exists on the hard drive before attempting to open the file in the first place (thereby avoiding the exception altogether). However, to stay focused on the topic of exceptions, assume the exception has been raised.
现在，如果指定的文件不在 C： 驱动器上，则调用 File.Open（） 会导致 FileNotFoundException！在本书的后面部分，您将了解有关 System.IO 命名空间的所有信息，您将在其中了解如何在尝试打开文件之前以编程方式确定硬盘驱动器上是否存在文件（从而完全避免异常）。但是，为了继续关注异常主题，请假设已引发异常。

When you encounter an exception while processing another exception, best practice states that you should record the new exception object as an “inner exception” within a new object of the same type as the initial exception. (That was a mouthful!) The reason you need to allocate a new object of the exception being handled is that the only way to document an inner exception is via a constructor parameter. Consider the following code:
现在，如果指定的文件不在 C： 驱动器上，则调用 File.Open（） 会导致 FileNotFoundException！在本书的后面部分，您将了解有关 System.IO 命名空间的所有信息，您将在其中了解如何在尝试打开文件之前以编程方式确定硬盘驱动器上是否存在文件（从而完全避免异常）。但是，为了继续关注异常主题，请假设已引发异常。

//Update the exception handler catch (CarIsDeadException e)
{

try
{
FileStream fs = File.Open(@"C:\carErrors.txt", FileMode.Open);
…
}
catch (Exception e2)
{
//This causes a compile error-InnerException is read only
//e.InnerException = e2;
// Throw an exception that records the new exception,
// as well as the message of the first exception.
throw new CarIsDeadException( e.CauseOfError, e.ErrorTimeStamp, e.Message, e2); }
}

Notice, in this case, I have passed in the FileNotFoundException object as the fourth parameter to the CarIsDeadException constructor. After you have configured this new object, you throw it up the call stack to the next caller, which in this case would be the top-level statements.
请注意，在本例中，我已经将FileNotFoundException对象作为第四个参数传递给CarIsDeadException构造函数。配置此新对象后，将其将调用堆栈抛出给下一个调用方，在本例中为顶级语句。

Given that there is no “next caller” after the top-level statements to catch the exception, you would be again presented with an error dialog box. Much like the act of rethrowing an exception, recording inner exceptions is usually useful only when the caller has the ability to gracefully catch the exception in the first place. If this is the case, the caller’s catch logic can use the InnerException property to extract the details of the inner exception object.
鉴于顶级语句后没有“下一个调用方”来捕获异常，您将再次看到一个错误对话框。与重新引发异常的行为非常相似，记录内部异常通常仅在调用方能够首先优雅地捕获异常时才有用。如果是这种情况，调用方的 catch 逻辑可以使用 InnerException 属性提取内部异常对象的详细信息。

The finally Block

最后的街区
A try/catch scope may also define an optional finally block. The purpose of a finally block is to ensure that a set of code statements will always execute, exception (of any type) or not. To illustrate, assume you want to always power down the car’s radio before exiting the program, regardless of any handled exception.
try/catch 范围也可以定义一个可选的 finally 块。finally 块的目的是确保一组代码语句始终执行，无论是否异常（任何类型的）。为了说明这一点，假设您希望始终在退出程序之前关闭汽车的收音机，而不管任何处理的异常。

Console.WriteLine(" Handling Multiple Exceptions \n"); Car myCar = new Car("Rusty", 90);
myCar.CrankTunes(true); try
{
// Speed up car logic.
}
catch(CarIsDeadException e)
{
// Process CarIsDeadException.
}
catch(ArgumentOutOfRangeException e)
{
// Process ArgumentOutOfRangeException.
}
catch(Exception e)
{
// Process any other Exception.
}

finally
{
// This will always occur. Exception or not. myCar.CrankTunes(false);
}
Console.ReadLine();

If you did not include a finally block, the radio would not be turned off if an exception were encountered (which might or might not be problematic). In a more real-world scenario, when you need to dispose of objects, close a file, or detach from a database (or whatever), a finally block ensures a location for proper cleanup.
如果未包含 finally 块，则在遇到异常时不会关闭无线电（可能会也可能没有问题）。在更真实的场景中，当您需要释放对象、关闭文件或从数据库分离（或其他任何内容）时，finally 块可确保正确清理的位置。

Exception Filters

异常筛选器

C# 6 introduced a new clause that can be placed on a catch scope, via the when keyword. When you add this clause, you have the ability to ensure that the statements within a catch block are executed only if some condition in your code holds true. This expression must evaluate to a Boolean (true or false) and can be obtained by using a simple code statement in the when definition itself or by calling an additional method in your code. In a nutshell, this approach allows you to add “filters” to your exception logic.
C# 6 引入了一个新子句，可以通过 when 关键字将其放置在 catch 作用域中。添加此子句时，能够确保仅当代码中的某些条件成立时，才执行 catch 块中的语句。此表达式的计算结果必须为布尔值（真或假），可以通过在 when 定义本身中使用简单的代码语句或在代码中调用其他方法来获取。简而言之，此方法允许您向异常逻辑添加“筛选器”。

Consider the following modified exception logic. I have added a when clause to the CarIsDeadException handler to ensure the catch block is never executed on a Friday (a contrived example, but who wants their automobile to break down right before the weekend?). Notice that the single Boolean statement in the when clause must be wrapped in parentheses.
请考虑以下修改后的异常逻辑。我在 CarIsDeadException 处理程序中添加了一个 when 子句，以确保 catch 块永远不会在星期五执行（一个人为的例子，但谁希望他们的汽车在周末之前发生故障？请注意，when 子句中的单个布尔语句必须括在括号中。

catch (CarIsDeadException e) when (e.ErrorTimeStamp.DayOfWeek != DayOfWeek.Friday)
{
// This new line will only print if the when clause evaluates to true.
// 仅当 when 子句的计算结果为 true 时，才会打印此新行。
Console.WriteLine("Catching car is dead!");

Console.WriteLine(e.Message);
}

While this example is very contrived, a more realistic use for using an exception filter is to catch SystemExceptions. For example, suppose your code is saving data to the database, a general exception is thrown. By examining the message and exception data, you can create specific handlers based on what caused the exception.
虽然此示例非常人为，但使用异常筛选器的更实际用途是捕获 SystemException。例如，假设您的代码正在将数据保存到数据库，则会引发常规异常。通过检查消息和异常数据，可以根据导致异常的原因创建特定的处理程序。

// Debugging Unhandled Exceptions Using Visual Studio
使用 Visual Studio 调试未经处理的异常

Visual Studio supplies a number of tools that help you debug unhandled exceptions. Assume you have increased the speed of a Car object beyond the maximum but this time did not bother to wrap your call within a try block.
Visual Studio 提供了许多工具来帮助你调试未经处理的异常。假设您已将 Car 对象的速度提高到超过最大值，但这次没有费心将您的调用包装在 try 块中。
Car myCar = new Car("Rusty", 90); myCar.Accelerate(100);

If you start a debugging session within Visual Studio (using the Debug ➤ Start Debugging menu selection), Visual Studio automatically breaks at the time the uncaught exception is thrown. Better yet, you are presented with a window (see Figure 7-1) displaying the value of the Message property.
如果在 Visual Studio 中启动调试会话（使用“调试”➤“启动调试”菜单选项），则在引发未捕获的异常时，Visual Studio 会自动中断。更好的是，您将看到一个窗口（请参阅图 7-1），其中显示了 Message 属性的值。

Figure 7-1. Debugging unhandled custom exceptions with Visual Studio
图 7-1。 使用 Visual Studio 调试未经处理的自定义异常

■ Note If you fail to handle an exception thrown by a method in the .neT base class libraries, the Visual studio debugger breaks at the statement that called the offending method.
注意 如果无法处理 .neT 基类库中的方法引发的异常，Visual Studio 调试器将在调用违规方法的语句处中断。

If you click the View Detail link, you will find the details regarding the state of the object (see Figure 7-2).
如果单击“查看详细信息”链接，将找到有关对象状态的详细信息（请参阅图 7-2）。

Figure 7-2. Viewing exception details
图 7-2。 查看异常详细信息

Summary

总结

In this chapter, you examined the role of structured exception handling. When a method needs to send an error object to the caller, it will allocate, configure, and throw a specific System.Exception-derived type via throw(). The caller is able to handle any possible incoming exceptions using the C# catch keyword and an optional finally scope. Since C# 6.0, the ability to create exception filters using the optional when keyword was added, and C# 7 has expanded the locations from where you can throw exceptions.
在本章中，您研究了结构化异常处理的作用。当方法需要向调用方发送错误对象时，它将通过 throw（） 分配、配置和抛出特定的 System.Exception 派生类型。调用方能够使用 C# catch 关键字和可选的 finally 作用域处理任何可能的传入异常。自 C# 6.0 起，添加了使用可选 when 关键字创建异常筛选器的功能，并且 C# 7 扩展了可以引发异常的位置。

When you are creating your own custom exceptions, you ultimately create a class type deriving from System.ApplicationException, which denotes an exception thrown from the currently executing
application. In contrast, error objects deriving from System.SystemException represent critical (and fatal)
errors thrown by the .NET runtime. Last but not least, this chapter illustrated various tools within Visual Studio that can be used to create custom exceptions (according to .NET best practices) as well as debug exceptions.
在创建自己的自定义异常时，最终会创建一个派生自 System.ApplicationException 的类类型，该类类型表示从当前执行的应用。相反，派生自 System.SystemException 的错误对象表示严重（和严重）.NET 运行时引发的错误。最后但并非最不重要的一点是，本章演示了Visual Studio中的各种工具，这些工具可用于创建自定义异常（根据.NET最佳实践）以及调试异常。