不鼓励只捕获System.Exception。相反，只应捕获“已知”异常。
现在，这有时会导致不必要的重复代码，例如：
try
{
WebId = new Guid(queryString["web"]);
}
catch (FormatException)
{
WebId = Guid.Empty;
}
catch (OverflowException)
{
WebId = Guid.Empty;
}
我想知道：是否有一种方法可以捕获两个异常，并且只调用WebId=Guid.Empty调用一次？
给定的示例相当简单，因为它只是一个GUID。但是想象一下，在代码中，您多次修改一个对象，如果其中一个操作预期失败，您希望“重置”该对象。然而，如果有意外的异常，我仍然想把它推得更高。
当前回答
C#9的更新
使用C#9中的新模式匹配增强功能，可以缩短异常过滤器中的表达式。现在，捕获多个异常很简单，如下所示：
try
{
WebId = new Guid(queryString["web"]);
}
catch (Exception e) when (e is FormatException or OverflowException)
{
WebId = Guid.Empty;
}
其他回答
所以你在每个异常开关中重复了很多代码？听起来提取一个方法是个好主意，不是吗？
因此，您的代码归结为：
MyClass instance;
try { instance = ... }
catch(Exception1 e) { Reset(instance); }
catch(Exception2 e) { Reset(instance); }
catch(Exception) { throw; }
void Reset(MyClass instance) { /* reset the state of the instance */ }
我想知道为什么没有人注意到代码重复。
从C#6中，您还可以使用其他人已经提到的异常过滤器。因此，您可以将上面的代码修改为：
try { ... }
catch(Exception e) when(e is Exception1 || e is Exception2)
{
Reset(instance);
}
异常过滤器现在在c#6+中可用。你可以的
try
{
WebId = new Guid(queryString["web"]);
}
catch (Exception ex) when(ex is FormatException || ex is OverflowException)
{
WebId = Guid.Empty;
}
在C#7.0+中，您也可以将其与模式匹配相结合
try
{
await Task.WaitAll(tasks);
}
catch (Exception ex) when( ex is AggregateException ae &&
ae.InnerExceptions.Count > tasks.Count/2)
{
//More than half of the tasks failed maybe..?
}
更新2015-12-15：参见https://stackoverflow.com/a/22864936/1718702对于C#6。这是一种更干净的语言，现在是标准的语言。
为了适合那些想要一次捕获并过滤异常的更优雅解决方案的人，我使用了如下所示的扩展方法。
我的库中已经有了这个扩展，它最初是为了其他目的而编写的，但它对于异常的类型检查非常有效。另外，我的意思是，它看起来比一堆||语句更干净。此外，与公认的答案不同，我更喜欢显式异常处理，因此ex是。。。具有不期望的行为，因为派生类可分配给父类型）。
用法
if (ex.GetType().IsAnyOf(
typeof(FormatException),
typeof(ArgumentException)))
{
// Handle
}
else
throw;
IsAnyOf.cs扩展（请参阅从属项的完整错误处理示例）
namespace Common.FluentValidation
{
public static partial class Validate
{
/// <summary>
/// Validates the passed in parameter matches at least one of the passed in comparisons.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="p_parameter">Parameter to validate.</param>
/// <param name="p_comparisons">Values to compare against.</param>
/// <returns>True if a match is found.</returns>
/// <exception cref="ArgumentNullException"></exception>
public static bool IsAnyOf<T>(this T p_parameter, params T[] p_comparisons)
{
// Validate
p_parameter
.CannotBeNull("p_parameter");
p_comparisons
.CannotBeNullOrEmpty("p_comparisons");
// Test for any match
foreach (var item in p_comparisons)
if (p_parameter.Equals(item))
return true;
// Return no matches found
return false;
}
}
}
完整错误处理示例（复制粘贴到新控制台应用程序）
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Common.FluentValidation;
namespace IsAnyOfExceptionHandlerSample
{
class Program
{
static void Main(string[] args)
{
// High Level Error Handler (Log and Crash App)
try
{
Foo();
}
catch (OutOfMemoryException ex)
{
Console.WriteLine("FATAL ERROR! System Crashing. " + ex.Message);
Console.ReadKey();
}
}
static void Foo()
{
// Init
List<Action<string>> TestActions = new List<Action<string>>()
{
(key) => { throw new FormatException(); },
(key) => { throw new ArgumentException(); },
(key) => { throw new KeyNotFoundException();},
(key) => { throw new OutOfMemoryException(); },
};
// Run
foreach (var FooAction in TestActions)
{
// Mid-Level Error Handler (Appends Data for Log)
try
{
// Init
var SomeKeyPassedToFoo = "FooParam";
// Low-Level Handler (Handle/Log and Keep going)
try
{
FooAction(SomeKeyPassedToFoo);
}
catch (Exception ex)
{
if (ex.GetType().IsAnyOf(
typeof(FormatException),
typeof(ArgumentException)))
{
// Handle
Console.WriteLine("ex was {0}", ex.GetType().Name);
Console.ReadKey();
}
else
{
// Add some Debug info
ex.Data.Add("SomeKeyPassedToFoo", SomeKeyPassedToFoo.ToString());
throw;
}
}
}
catch (KeyNotFoundException ex)
{
// Handle differently
Console.WriteLine(ex.Message);
int Count = 0;
if (!Validate.IsAnyNull(ex, ex.Data, ex.Data.Keys))
foreach (var Key in ex.Data.Keys)
Console.WriteLine(
"[{0}][\"{1}\" = {2}]",
Count, Key, ex.Data[Key]);
Console.ReadKey();
}
}
}
}
}
namespace Common.FluentValidation
{
public static partial class Validate
{
/// <summary>
/// Validates the passed in parameter matches at least one of the passed in comparisons.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="p_parameter">Parameter to validate.</param>
/// <param name="p_comparisons">Values to compare against.</param>
/// <returns>True if a match is found.</returns>
/// <exception cref="ArgumentNullException"></exception>
public static bool IsAnyOf<T>(this T p_parameter, params T[] p_comparisons)
{
// Validate
p_parameter
.CannotBeNull("p_parameter");
p_comparisons
.CannotBeNullOrEmpty("p_comparisons");
// Test for any match
foreach (var item in p_comparisons)
if (p_parameter.Equals(item))
return true;
// Return no matches found
return false;
}
/// <summary>
/// Validates if any passed in parameter is equal to null.
/// </summary>
/// <param name="p_parameters">Parameters to test for Null.</param>
/// <returns>True if one or more parameters are null.</returns>
public static bool IsAnyNull(params object[] p_parameters)
{
p_parameters
.CannotBeNullOrEmpty("p_parameters");
foreach (var item in p_parameters)
if (item == null)
return true;
return false;
}
}
}
namespace Common.FluentValidation
{
public static partial class Validate
{
/// <summary>
/// Validates the passed in parameter is not null, throwing a detailed exception message if the test fails.
/// </summary>
/// <param name="p_parameter">Parameter to validate.</param>
/// <param name="p_name">Name of tested parameter to assist with debugging.</param>
/// <exception cref="ArgumentNullException"></exception>
public static void CannotBeNull(this object p_parameter, string p_name)
{
if (p_parameter == null)
throw
new
ArgumentNullException(
string.Format("Parameter \"{0}\" cannot be null.",
p_name), default(Exception));
}
}
}
namespace Common.FluentValidation
{
public static partial class Validate
{
/// <summary>
/// Validates the passed in parameter is not null or an empty collection, throwing a detailed exception message if the test fails.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="p_parameter">Parameter to validate.</param>
/// <param name="p_name">Name of tested parameter to assist with debugging.</param>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentOutOfRangeException"></exception>
public static void CannotBeNullOrEmpty<T>(this ICollection<T> p_parameter, string p_name)
{
if (p_parameter == null)
throw new ArgumentNullException("Collection cannot be null.\r\nParameter_Name: " + p_name, default(Exception));
if (p_parameter.Count <= 0)
throw new ArgumentOutOfRangeException("Collection cannot be empty.\r\nParameter_Name: " + p_name, default(Exception));
}
/// <summary>
/// Validates the passed in parameter is not null or empty, throwing a detailed exception message if the test fails.
/// </summary>
/// <param name="p_parameter">Parameter to validate.</param>
/// <param name="p_name">Name of tested parameter to assist with debugging.</param>
/// <exception cref="ArgumentException"></exception>
public static void CannotBeNullOrEmpty(this string p_parameter, string p_name)
{
if (string.IsNullOrEmpty(p_parameter))
throw new ArgumentException("String cannot be null or empty.\r\nParameter_Name: " + p_name, default(Exception));
}
}
}
两个NUnit单元测试示例
异常类型的匹配行为是精确的（即，子类型与其任何父类型都不匹配）。
using System;
using System.Collections.Generic;
using Common.FluentValidation;
using NUnit.Framework;
namespace UnitTests.Common.Fluent_Validations
{
[TestFixture]
public class IsAnyOf_Tests
{
[Test, ExpectedException(typeof(ArgumentNullException))]
public void IsAnyOf_ArgumentNullException_ShouldNotMatch_ArgumentException_Test()
{
Action TestMethod = () => { throw new ArgumentNullException(); };
try
{
TestMethod();
}
catch (Exception ex)
{
if (ex.GetType().IsAnyOf(
typeof(ArgumentException), /*Note: ArgumentNullException derrived from ArgumentException*/
typeof(FormatException),
typeof(KeyNotFoundException)))
{
// Handle expected Exceptions
return;
}
//else throw original
throw;
}
}
[Test, ExpectedException(typeof(OutOfMemoryException))]
public void IsAnyOf_OutOfMemoryException_ShouldMatch_OutOfMemoryException_Test()
{
Action TestMethod = () => { throw new OutOfMemoryException(); };
try
{
TestMethod();
}
catch (Exception ex)
{
if (ex.GetType().IsAnyOf(
typeof(OutOfMemoryException),
typeof(StackOverflowException)))
throw;
/*else... Handle other exception types, typically by logging to file*/
}
}
}
}
编辑：我确实同意其他人的观点，即从C#6.0开始，异常过滤器现在是一个非常好的方法：在（ex是…||ex是…）时捕获（exception ex）
除了我仍然有点讨厌一行长的布局，我个人会像下面这样布局代码。我认为这既实用又美观，因为我相信它能提高理解力。有些人可能不同意：
catch (Exception ex) when (
ex is ...
|| ex is ...
|| ex is ...
)
原件：
我知道我来这里参加派对有点晚了，但圣烟。。。
直接切入主题，这种类型重复了前面的答案，但如果您真的想对几个异常类型执行一个通用操作，并在一个方法的范围内保持整个操作的整洁，为什么不使用lambda/closure/inline函数来执行以下操作呢？我的意思是，很有可能你最终会意识到你只是想让闭包成为一个单独的方法，你可以在所有地方使用它。但是，这样做将非常容易，而实际上不需要从结构上改变代码的其余部分。正确的
private void TestMethod ()
{
Action<Exception> errorHandler = ( ex ) => {
// write to a log, whatever...
};
try
{
// try some stuff
}
catch ( FormatException ex ) { errorHandler ( ex ); }
catch ( OverflowException ex ) { errorHandler ( ex ); }
catch ( ArgumentNullException ex ) { errorHandler ( ex ); }
}
我忍不住想知道（警告：前面有点讽刺/讽刺），到底为什么要这么做，基本上只是取代以下内容：
try
{
// try some stuff
}
catch( FormatException ex ){}
catch( OverflowException ex ){}
catch( ArgumentNullException ex ){}
……我是说，下一个代码的味道有一些疯狂的变化，只是假装你节省了几个按键。
// sorta sucks, let's be honest...
try
{
// try some stuff
}
catch( Exception ex )
{
if (ex is FormatException ||
ex is OverflowException ||
ex is ArgumentNullException)
{
// write to a log, whatever...
return;
}
throw;
}
因为它当然不会自动变得更可读。
当然，我留下了/*写入日志的三个相同实例，不管怎样…*/回来在第一个例子中。
但这是我的观点。你们都听说过函数/方法，对吧？认真地编写一个通用的ErrorHandler函数，然后从每个catch块调用它。
若你们问我，第二个例子（带有If和is关键字）的可读性明显降低，同时在项目的维护阶段也更容易出错。
对于任何可能对编程相对陌生的人来说，维护阶段将占项目整个生命周期的98.7%或更多，而做维护的可怜的笨蛋几乎肯定会是其他人。而且他们很有可能会在工作中花费50%的时间咒骂你的名字。
当然，FxCop会对你咆哮，所以你还必须在代码中添加一个属性，该属性与正在运行的程序完全相关，它只是告诉FxCop忽略一个问题，在99.9%的情况下，它在标记中是完全正确的。抱歉，我可能搞错了，但“忽略”属性最终不是真正编译到了你的应用程序中吗？
将整个if测试放在一行上会让它更易读吗？我不这么认为。我的意思是，很久以前，我确实有另一位程序员激烈地争辩说，在一行代码中添加更多代码会让它“运行得更快”。但当然，他是个彻头彻尾的疯子。试图向他解释（用一副严肃的面孔——这很有挑战性），解释程序或编译器如何将那条长的行分割成每行一条指令的离散语句——基本上与如果他继续下去，只是让代码可读，而不是试图让编译器变得聪明的话，结果是一样的——对他没有任何影响。但我跑题了。
当您在一两个月后再添加三种异常类型时，这会降低多少可读性？（答：它的可读性大大降低）。
其中一个要点是，格式化我们每天都在查看的文本源代码的主要目的是让其他人真正了解代码运行时的实际情况。因为编译器会将源代码转换成完全不同的东西，并且不会对代码格式样式不太在意。所以一条线上的一切也很糟糕。
只是说。。。
// super sucks...
catch( Exception ex )
{
if ( ex is FormatException || ex is OverflowException || ex is ArgumentNullException )
{
// write to a log, whatever...
return;
}
throw;
}
想在这条已经很长的线索上加上我的简短回答。还没有提到的是catch语句的优先顺序，更具体地说，您需要了解您试图捕获的每种类型的异常的范围。
例如，如果您使用“catch-all”异常作为异常，它将优先于所有其他catch语句，您显然会遇到编译器错误。但是，如果您颠倒了catch语句的顺序（我认为这有点反模式），您可以将catch-allException类型放在底部，这将捕获任何在尝试中不适合更高级别的异常。。捕捉块：
try
{
// do some work here
}
catch (WebException ex)
{
// catch a web excpetion
}
catch (ArgumentException ex)
{
// do some stuff
}
catch (Exception ex)
{
// you should really surface your errors but this is for example only
throw new Exception("An error occurred: " + ex.Message);
}
我强烈建议大家阅读此MSDN文档：
异常层次结构
