C# Wie, um mehrere Ausnahmen, die nicht alle gleich?

Du machst es richtig (Sie fangen sollte nur die Ausnahmen, die Sie gehen zu behandeln, und es keine Möglichkeit gibt, fangen Sie mehr als ein exception-Typ in einem einzigen catch block), aber als alternative, können Sie einfach catch(Exception ex), den Typ der Ausnahme prüfen, und wenn es ist nicht eine, die Sie erwarten gerade throw es wieder, so etwas wie dieses:

var exceptionTypes=new Type[] {
    typeof(FileNotFoundException),
    typeof(ArgumentNullException),
    //...add other types here
};

catch(Exception ex) {
    if(exceptionTypes.Contains(ex.GetType()) {
        HandleException(ex);
    } else {
        throw;
    }
}

UPDATE: Mit C# 6 (kommt zusammen mit Visual Studio 2015) Sie sind in der Lage, führen Sie die folgenden stattdessen:

catch(Exception ex) when (exceptionTypes.Contains(ex.GetType()) {
    HandleException(ex);
}

Können Sie Generika für eine viel bessere Lösung, solange es Ihnen nichts ausmacht mit Lambda zu. Ich bin kein fan von ein-geben. Ich habe diesen code ein paar mal, ich finde es kommt in besonders praktisch für Dienst-proxies, in dem Sie möchten, um zu behandeln eine Reihe von Ausnahmen, die in der gleichen Weise. Wie schon oben erwähnt es ist immer am besten fangen Sie die richtige Art von Ausnahme, wo möglich.

Den code durch Angabe der Ausnahmen als generischen Typ-Argumente für den Griff-Funktion. Diese speziellen Typen sind dann gefangen, aber übergeben, um einen generischen handler der Basisklasse. Ich wusste nicht fügen Sie eine HandleAndThrow aber diese können Hinzugefügt werden, wie gewünscht. Auch ändern Sie Benennung, um Ihren wünschen.

    public static void Handle<T>(Action action, Action<T> handler)
        where T : Exception
    {
        try
        {
            action();
        }
        catch (T exception)
        {
            handler(exception);
        }
    }

    public static void Handle<T1, T2>(Action action, Action<Exception> handler)
        where T1 : Exception
        where T2 : Exception
    {
        try
        {
            action();
        }
        catch (T1 exception)
        {
            handler(exception);
        }
        catch (T2 exception)
        {
            handler(exception);
        }
    }

    public static void Handle<T1, T2, T3>(Action action, Action<Exception> handler)
        where T1 : Exception
        where T2 : Exception
        where T3 : Exception
    {
        try
        {
            action();
        }
        catch (T1 exception)
        {
            handler(exception);
        }
        catch (T2 exception)
        {
            handler(exception);
        }
        catch (T3 exception)
        {
            handler(exception);
        }
    }

    public static void Handle<T1, T2, T3, T4>(Action action, Action<Exception> handler)
        where T1 : Exception
        where T2 : Exception
        where T3 : Exception
        where T4 : Exception
    {
        try
        {
            action();
        }
        catch (T1 exception)
        {
            handler(exception);
        }
        catch (T2 exception)
        {
            handler(exception);
        }
        catch (T3 exception)
        {
            handler(exception);
        }
        catch (T4 exception)
        {
            handler(exception);
        }
    }
}

public class Example
{
    public void LoadControl()
    {
        Exceptions.Handle<FileNotFoundException, ArgumentNullException, NullReferenceException>(() => LoadControlCore(10), GenericExceptionHandler);   
    }

    private void LoadControlCore(int myArguments)
    {
        //execute method as normal
    }

    public void GenericExceptionHandler(Exception e)
    {
        //do something
        Debug.WriteLine(e.Message);
    }        
}

Werde ich diese zu beantworten ist eine sprachunabhängige Weise:

1. Was Sie getan haben, ist jetzt korrekt. Nichts falsch mit ihm, außer, dass es vielleicht langweilig werden, wenn Sie es tun, viele Male.

2. Fangen der allgemeinsten form der Ausnahme, dass es ist. Einfach

catch(Exception e)
{
    ...
}

3. Vielleicht wollen Sie nur fangen einige Ausnahmen, ohne Probleme alle Ausnahmen, das ist, was Sie tun würde, wenn Sie Tat genau #2.

Tun, was Sie schon in #2, plus ändern HandleException zu behandeln nur bestimmte Typen von Ausnahmen. Auf diese Weise werden Sie nur überhaupt nichts zu tun haben Typ tem mal raus, und es ist immer noch kompakter als die oben.

private void HandleException(Exception e) throws Excpetion
{
    //Reject some types of exceptions
    if (!((e is FileNotFoundException) ||
        (e is ArgumentNullException) ||
        (e is HttpException ) ||
        (e is IncorrectInheritanceException )))
    {
        throw;
    }

    //Rest of code
    ...
}

Edit:

Sehe ich Konamiman hat eine verbesserte version dieser Dritte option. Ich sagen, gehen dafür.