所以你在每个异常开关中重复了很多代码？听起来提取一个方法是个好主意，不是吗？

因此，您的代码归结为：

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

我想建议最简短的答案（一种更实用的方式）：

        Catch<FormatException, OverflowException>(() =>
            {
                WebId = new Guid(queryString["web"]);
            },
            exception =>
            {
                WebId = Guid.Empty;
            });

为此，您需要创建几个“Catch”方法重载，类似于System.Action：

    [DebuggerNonUserCode]
    public static void Catch<TException1, TException2>(Action tryBlock,
        Action<Exception> catchBlock)
    {
        CatchMany(tryBlock, catchBlock, typeof(TException1), typeof(TException2));
    }

    [DebuggerNonUserCode]
    public static void Catch<TException1, TException2, TException3>(Action tryBlock,
        Action<Exception> catchBlock)
    {
        CatchMany(tryBlock, catchBlock, typeof(TException1), typeof(TException2), typeof(TException3));
    }

你想多少就多少。但是你需要做一次，你可以在所有项目中使用它（或者，如果你创建了一个nuget包，我们也可以使用它）。

以及CatchMany实施：

    [DebuggerNonUserCode]
    public static void CatchMany(Action tryBlock, Action<Exception> catchBlock,
        params Type[] exceptionTypes)
    {
        try
        {
            tryBlock();
        }
        catch (Exception exception)
        {
            if (exceptionTypes.Contains(exception.GetType())) catchBlock(exception);
            else throw;
        }
    }

p.s.为了代码的简单性，我没有进行空检查，请考虑添加参数验证。

第2页如果要从catch返回值，则必须执行相同的catch方法，但在参数中使用return和Func而不是Action。

在c#6.0中，异常过滤器是对异常处理的改进

try
{
    DoSomeHttpRequest();
}
catch (System.Web.HttpException e)
{
    switch (e.GetHttpCode())
    {
        case 400:
            WriteLine("Bad Request");
        case 500:
            WriteLine("Internal Server Error");
        default:
            WriteLine("Generic Error");
    }
}

警告和警告：另一种功能性风格。

链接中的内容不会直接回答您的问题，但将其扩展为以下内容很简单：

static void Main() 
{ 
    Action body = () => { ...your code... };

    body.Catch<InvalidOperationException>() 
        .Catch<BadCodeException>() 
        .Catch<AnotherException>(ex => { ...handler... })(); 
}

（基本上提供另一个返回自身的空Catch重载）

更大的问题是为什么。我不认为这里的成本大于收益：）

所以你在每个异常开关中重复了很多代码？听起来提取一个方法是个好主意，不是吗？

因此，您的代码归结为：

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

想在这条已经很长的线索上加上我的简短回答。还没有提到的是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文档：

异常层次结构