公认的答案似乎是可以接受的，除了CodeAnalysis/FxCop会抱怨它捕获了一般的异常类型。

此外，“is”运算符似乎会稍微降低性能。

CA1800：不要进行不必要的强制转换。“请考虑测试‘as’运算符的结果”，但如果这样做，您将编写比单独捕获每个异常更多的代码。

无论如何，我会这样做：

bool exThrown = false;

try
{
    // Something
}
catch (FormatException) {
    exThrown = true;
}
catch (OverflowException) {
    exThrown = true;
}

if (exThrown)
{
    // Something else
}

如果您不想在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方法。

这是马特的答案的变体（我觉得这有点干净）。。。使用一种方法：

public void TryCatch(...)
{
    try
    {
       // something
       return;
    }
    catch (FormatException) {}
    catch (OverflowException) {}

    WebId = Guid.Empty;
}

将引发任何其他异常，代码WebId=Guid.Empty；不会被击中。如果您不希望其他异常使您的程序崩溃，只需在其他两个捕获之后添加这个：

...
catch (Exception)
{
     // something, if anything
     return; // only need this if you follow the example I gave and put it all in a method
}

编辑：我确实同意其他人的观点，即从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;
}

这是每个C#开发人员最终面临的一个经典问题。

让我把你的问题分成两个问题。第一，

我可以一次捕获多个异常吗？

简而言之，没有。

这引出了下一个问题，

如果我不能在同一个catch（）块中捕获多个异常类型，如何避免编写重复代码？

给定您的特定示例，其中回退值构建起来很便宜，我喜欢遵循以下步骤：

将WebId初始化为回退值。在临时变量中构造新的Guid。将WebId设置为完全构造的临时变量。将此作为try｛｝块的最终语句。

所以代码看起来像：

try
{
    WebId = Guid.Empty;
    Guid newGuid = new Guid(queryString["web"]);
    // More initialization code goes here like 
    // newGuid.x = y;
    WebId = newGuid;
}
catch (FormatException) {}
catch (OverflowException) {}

如果引发任何异常，则WebId永远不会设置为半构造值，并且保持Guid.Empty。

如果构造回退值很昂贵，而重置一个值要便宜得多，那么我会将重置代码移动到它自己的函数中：

try
{
    WebId = new Guid(queryString["web"]);
    // More initialization code goes here.
}
catch (FormatException) {
    Reset(WebId);
}
catch (OverflowException) {
    Reset(WebId);
}

约瑟夫·戴格尔的答案是一个很好的解决方案，但我发现下面的结构更整洁，更不容易出错。

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
}