不鼓励只捕获System.Exception。相反，只应捕获“已知”异常。
现在，这有时会导致不必要的重复代码，例如：
try
{
WebId = new Guid(queryString["web"]);
}
catch (FormatException)
{
WebId = Guid.Empty;
}
catch (OverflowException)
{
WebId = Guid.Empty;
}
我想知道：是否有一种方法可以捕获两个异常，并且只调用WebId=Guid.Empty调用一次？
给定的示例相当简单，因为它只是一个GUID。但是想象一下，在代码中，您多次修改一个对象，如果其中一个操作预期失败，您希望“重置”该对象。然而，如果有意外的异常，我仍然想把它推得更高。
当前回答
约瑟夫·戴格尔的答案是一个很好的解决方案，但我发现下面的结构更整洁，更不容易出错。
catch(Exception ex)
{
if (!(ex is SomeException || ex is OtherException)) throw;
// Handle exception
}
反转表达式有几个优点：
return语句不是必需的代码未嵌套不存在忘记“抛出”或“返回”语句的风险，这些语句在Joseph的解决方案中与表达式分离。
它甚至可以压缩成一行（虽然不是很漂亮）
catch(Exception ex) { if (!(ex is SomeException || ex is OtherException)) throw;
// Handle exception
}
编辑：C#6.0中的异常过滤将使语法更加简洁，并比任何当前解决方案都有许多其他好处。（最值得注意的是，未损坏堆栈）
下面是使用C#6.0语法时相同问题的外观：
catch(Exception ex) when (ex is SomeException || ex is OtherException)
{
// Handle exception
}
其他回答
@密歇根州
代码的略微修订版本：
catch (Exception ex)
{
Type exType = ex.GetType();
if (exType == typeof(System.FormatException) ||
exType == typeof(System.OverflowException)
{
WebId = Guid.Empty;
} else {
throw;
}
}
字符串比较既丑陋又缓慢。
编辑：我确实同意其他人的观点，即从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;
}
所以你在每个异常开关中重复了很多代码？听起来提取一个方法是个好主意，不是吗？
因此，您的代码归结为：
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#7，Michael Stum的答案可以得到改进，同时保持switch语句的可读性：
catch (Exception ex)
{
switch (ex)
{
case FormatException _:
case OverflowException _:
WebId = Guid.Empty;
break;
default:
throw;
}
}
由于Orace注释，这可以通过省略丢弃变量而用C#8来简化：
catch (Exception ex)
{
switch (ex)
{
case FormatException:
case OverflowException:
WebId = Guid.Empty;
break;
default:
throw;
}
}
使用C#8作为开关表达式：
catch (Exception ex)
{
WebId = ex switch
{
_ when ex is FormatException || ex is OverflowException => Guid.Empty,
_ => throw ex
};
}
正如内切米娅·霍夫曼指出的那样。后一个示例将导致堆栈丢失。这可以通过使用Jürgen Steinblock描述的扩展方法来防止，以在投掷前捕获堆叠：
catch (Exception ex)
{
WebId = ex switch
{
_ when ex is FormatException || ex is OverflowException => Guid.Empty,
_ => throw ex.Capture()
};
}
public static Exception Capture(this Exception ex)
{
ExceptionDispatchInfo.Capture(ex).Throw();
return ex;
}
这两种样式都可以通过C#9的模式匹配增强来简化：
catch (Exception ex)
{
switch (ex)
{
case FormatException or OverflowException:
WebId = Guid.Empty;
break;
default:
throw;
}
}
catch (Exception ex)
{
WebId = ex switch
{
_ when ex is FormatException or OverflowException => Guid.Empty,
_ => throw ex.Capture()
};
}
如果您不想在catch范围内使用If语句，在C#6.0中，您可以使用CLR在预览版本中已经支持但仅存在于VB.NET/MSIL中的异常过滤器语法：
try
{
WebId = new Guid(queryString["web"]);
}
catch (Exception exception) when (exception is FormatException || ex is OverflowException)
{
WebId = Guid.Empty;
}
只有当异常为InvalidDataException或ArgumentNullException时，此代码才会捕获该异常。
实际上，你可以在when子句中放入基本上任何条件：
static int a = 8;
...
catch (Exception exception) when (exception is InvalidDataException && a == 8)
{
Console.WriteLine("Catch");
}
请注意，与catch范围内的if语句不同，异常过滤器不能抛出异常，当抛出异常时，或者当条件不为真时，将计算下一个catch条件：
static int a = 7;
static int b = 0;
...
try
{
throw new InvalidDataException();
}
catch (Exception exception) when (exception is InvalidDataException && a / b == 2)
{
Console.WriteLine("Catch");
}
catch (Exception exception) when (exception is InvalidDataException || exception is ArgumentException)
{
Console.WriteLine("General catch");
}
输出：常规捕获。
当存在多个真正的异常筛选器时，将接受第一个：
static int a = 8;
static int b = 4;
...
try
{
throw new InvalidDataException();
}
catch (Exception exception) when (exception is InvalidDataException && a / b == 2)
{
Console.WriteLine("Catch");
}
catch (Exception exception) when (exception is InvalidDataException || exception is ArgumentException)
{
Console.WriteLine("General catch");
}
输出：捕获。
正如您在MSIL中看到的，代码不是转换为if语句，而是转换为筛选器，并且异常不能从标记为筛选器1和筛选器2的区域中抛出，但是抛出异常的筛选器将失败，在endfilter命令之前推送到堆栈的最后一个比较值也将决定过滤器的成功/失败（Catch 1 XOR Catch 2将相应地执行）：
此外，特别是Guid具有Guid.TryParse方法。
