Mehrere Ausnahmen gleichzeitig abfangen?

Es wird davon abgeraten, einfach zu fangen System.Exception. Stattdessen sollten nur die "bekannten" Ausnahmen abgefangen werden.

Dies führt manchmal zu unnötigem sich wiederholendem Code, zum Beispiel:

try
{
    WebId = new Guid(queryString["web"]);
}
catch (FormatException)
{
    WebId = Guid.Empty;
}
catch (OverflowException)
{
    WebId = Guid.Empty;
}

Ich frage mich: Gibt es eine Möglichkeit, beide Ausnahmen abzufangen und den WebId = Guid.EmptyAnruf nur einmal anzurufen?

Das gegebene Beispiel ist ziemlich einfach, da es nur ein ist GUID. Stellen Sie sich jedoch Code vor, in dem Sie ein Objekt mehrmals ändern. Wenn eine der Manipulationen erwartungsgemäß fehlschlägt, möchten Sie das Objekt "zurücksetzen" object. Wenn es jedoch eine unerwartete Ausnahme gibt, möchte ich diese trotzdem höher werfen.

Fangen System.Exceptionund schalten Sie die Typen ein

catch (Exception ex)            
{                
    if (ex is FormatException || ex is OverflowException)
    {
        WebId = Guid.Empty;
        return;
    }

    throw;
}

BEARBEITEN: Ich stimme anderen zu, die sagen, dass Ausnahmefilter ab C # 6.0 jetzt ein perfekter Weg sind:catch (Exception ex) when (ex is ... || ex is ... )

Abgesehen davon, dass ich das einzeilige Layout immer noch hasse und den Code persönlich wie folgt auslegen würde. Ich denke, dies ist ebenso funktional wie ästhetisch, da ich glaube, dass es das Verständnis verbessert. Einige mögen anderer Meinung sein:

catch (Exception ex) when (
    ex is ...
    || ex is ...
    || ex is ...
)

ORIGINAL:

Ich weiß, ich bin ein bisschen zu spät zur Party hier, aber heiliger Rauch ...

Auf den Punkt gebracht, dupliziert diese Art eine frühere Antwort. Wenn Sie jedoch wirklich eine gemeinsame Aktion für mehrere Ausnahmetypen ausführen und das Ganze im Rahmen der einen Methode ordentlich und ordentlich halten möchten, verwenden Sie doch einfach ein Lambda / Closure / Inline-Funktion, um Folgendes zu tun? Ich meine, die Chancen stehen gut, dass Sie am Ende erkennen, dass Sie diesen Verschluss nur zu einer separaten Methode machen möchten, die Sie überall anwenden können. Aber dann wird es super einfach sein, dies zu tun, ohne den Rest des Codes strukturell zu ändern. Recht?

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

Ich kann nicht anders, als mich zu fragen ( Warnung: ein wenig Ironie / Sarkasmus voraus), warum um alles in der Welt all diese Anstrengungen unternommen werden, um im Grunde nur Folgendes zu ersetzen:

try
{
    // try some stuff
}
catch( FormatException ex ){}
catch( OverflowException ex ){}
catch( ArgumentNullException ex ){}

... mit einer verrückten Variation dieses nächsten Codegeruchs, meine ich zum Beispiel, nur um so zu tun, als würden Sie ein paar Tastenanschläge speichern.

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

Weil es sicherlich nicht automatisch besser lesbar ist.

Zugegeben, ich habe die drei identischen Instanzen /* write to a log, whatever... */ return;aus dem ersten Beispiel herausgelassen.

Aber das ist irgendwie mein Punkt. Sie haben schon von Funktionen / Methoden gehört, oder? Ernsthaft. Schreiben Sie eine gemeinsame ErrorHandlerFunktion und rufen Sie sie von jedem catch-Block aus auf.

Wenn Sie mich fragen, ist das zweite Beispiel (mit den Schlüsselwörtern ifund is) sowohl deutlich weniger lesbar als auch gleichzeitig während der Wartungsphase Ihres Projekts wesentlich fehleranfälliger.

Die Wartungsphase für alle, die noch relativ neu in der Programmierung sind, wird 98,7% oder mehr der gesamten Lebensdauer Ihres Projekts ausmachen, und der arme Trottel, der die Wartung durchführt, wird mit ziemlicher Sicherheit jemand anderes als Sie sein. Und es besteht eine sehr gute Chance, dass sie 50% ihrer Zeit damit verbringen, Ihren Namen zu verfluchen.

Und natürlich bellt FxCop Sie an, und deshalb müssen Sie Ihrem Code auch ein Attribut hinzufügen, das genau mit dem laufenden Programm zu tun hat und nur dazu dient, FxCop anzuweisen, ein Problem zu ignorieren, das in 99,9% der Fälle vollständig auftritt richtig in der Kennzeichnung. Tut mir leid, ich könnte mich irren, aber wird dieses Attribut "Ignorieren" nicht tatsächlich in Ihre App kompiliert?

Würde ifes besser lesbar sein , den gesamten Test in eine Zeile zu setzen? Das glaube ich nicht. Ich meine, ich hatte vor langer Zeit einen anderen Programmierer, der vehement argumentierte, dass mehr Code in eine Zeile "schneller laufen" würde. Aber natürlich war er total verrückt. Der Versuch, ihm (mit ernstem Gesicht - was eine Herausforderung war) zu erklären, wie der Interpreter oder Compiler diese lange Zeile in diskrete Anweisungen mit einer Anweisung pro Zeile zerlegen würde - im Wesentlichen identisch mit dem Ergebnis, wenn er fortgefahren wäre und Ich habe nur den Code lesbar gemacht, anstatt zu versuchen, den Compiler zu überlisten - hatte keinerlei Auswirkungen auf ihn. Aber ich schweife ab.

Wie viel weniger lesbar wird dies, wenn Sie in ein oder zwei Monaten drei weitere Ausnahmetypen hinzufügen? (Antwort: es wird viel weniger lesbar).

Einer der wichtigsten Punkte ist, dass der größte Teil der Formatierung des Textquellcodes, den wir uns jeden Tag ansehen, darin besteht, anderen Menschen wirklich, wirklich klar zu machen, was tatsächlich passiert, wenn der Code ausgeführt wird. Weil der Compiler den Quellcode in etwas völlig anderes verwandelt und sich nicht weniger um Ihren Code-Formatierungsstil kümmert. All-on-One-Line ist also auch total beschissen.

Ich sage nur ...

// super sucks...
catch( Exception ex )
{
    if ( ex is FormatException || ex is OverflowException || ex is ArgumentNullException )
    {
        // write to a log, whatever...
        return;
    }
    throw;
}

Wie andere bereits betont haben, können Sie eine ifAnweisung in Ihrem catch-Block haben, um festzustellen, was los ist. C # 6 unterstützt Ausnahmefilter, daher funktioniert Folgendes:

try { … }
catch (Exception e) when (MyFilter(e))
{
    …
}

Die MyFilterMethode könnte dann ungefähr so ​​aussehen:

private bool MyFilter(Exception e)
{
  return e is ArgumentNullException || e is FormatException;
}

Alternativ kann dies alles inline erfolgen (die rechte Seite der when-Anweisung muss nur ein boolescher Ausdruck sein).

try { … }
catch (Exception e) when (e is ArgumentNullException || e is FormatException)
{
    …
}

Dies unterscheidet sich von der Verwendung einer ifAnweisung innerhalb des catchBlocks. Durch die Verwendung von Ausnahmefiltern wird der Stapel nicht abgewickelt.

Sie können Visual Studio 2015 herunterladen , um dies zu überprüfen.

Wenn Sie Visual Studio 2013 weiterhin verwenden möchten, können Sie das folgende Nuget-Paket installieren:

Installationspaket Microsoft.Net.Compilers

Zum Zeitpunkt des Schreibens umfasst dies die Unterstützung für C # 6.

Wenn Sie auf dieses Paket verweisen, wird das Projekt mit der spezifischen Version der im Paket enthaltenen C # - und Visual Basic-Compiler erstellt, im Gegensatz zu jeder vom System installierten Version.

Leider nicht in C #, da Sie dafür einen Ausnahmefilter benötigen und C # diese Funktion von MSIL nicht verfügbar macht. VB.NET verfügt jedoch über diese Funktion, z

Catch ex As Exception When TypeOf ex Is FormatException OrElse TypeOf ex Is OverflowException

Sie können eine anonyme Funktion verwenden, um Ihren Fehlercode zu kapseln und ihn dann in den folgenden Catch-Blöcken aufzurufen:

Action onError = () => WebId = Guid.Empty;
try
{
    // something
}
catch (FormatException)
{
    onError();
}
catch (OverflowException)
{
    onError();
}

Der Vollständigkeit halber kann der Code seit .NET 4.0 wie folgt umgeschrieben werden:

Guid.TryParse(queryString["web"], out WebId);

TryParse löst niemals Ausnahmen aus und gibt false zurück, wenn das Format falsch ist, und setzt WebId auf Guid.Empty.

Seit C # 7 können Sie vermeiden, eine Variable in eine separate Zeile einzufügen:

Guid.TryParse(queryString["web"], out Guid webId);

Sie können auch Methoden zum Parsen von zurückgegebenen Tupeln erstellen, die in .NET Framework ab Version 4.6 noch nicht verfügbar sind:

(bool success, Guid result) TryParseGuid(string input) =>
    (Guid.TryParse(input, out Guid result), result);

Und benutze sie so:

WebId = TryParseGuid(queryString["web"]).result;
// or
var tuple = TryParseGuid(queryString["web"]);
WebId = tuple.success ? tuple.result : DefaultWebId;

Das nächste nutzlose Update dieser nutzlosen Antwort erfolgt, wenn die Dekonstruktion von Out-Parametern in C # 12 implementiert ist. :)

Ausnahmefilter sind jetzt in c # 6+ verfügbar. Du kannst tun

try
{
       WebId = new Guid(queryString["web"]);
}
catch (Exception ex) when(ex is FormatException || ex is OverflowException)
{
     WebId = Guid.Empty;
}

In C # 7.0+ können Sie dies auch mit dem Mustervergleich kombinieren

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..? 
}

Wenn Sie Ihre Anwendung auf C # 6 aktualisieren können, haben Sie Glück. Die neue C # -Version hat Ausnahmefilter implementiert. Sie können also Folgendes schreiben:

catch (Exception ex) when (ex is FormatException || ex is OverflowException) {
    WebId = Guid.Empty;
}

Einige Leute denken, dieser Code ist der gleiche wie

catch (Exception ex) {                
    if (ex is FormatException || ex is OverflowException) {
        WebId = Guid.Empty;
    }
    throw;
}

Aber es ist nicht. Tatsächlich ist dies die einzige neue Funktion in C # 6, die in früheren Versionen nicht emuliert werden kann. Erstens bedeutet ein erneuter Wurf mehr Aufwand als das Überspringen des Fangs. Zweitens ist es nicht semantisch äquivalent. Die neue Funktion behält den Stapel beim Debuggen Ihres Codes bei. Ohne diese Funktion ist der Absturzspeicherauszug weniger nützlich oder sogar nutzlos.

Eine Diskussion hierzu finden Sie auf CodePlex . Und ein Beispiel, das den Unterschied zeigt .

Wenn Sie nicht über eine verwenden möchten ifAnweisung innerhalb der catchBereiche, in C# 6.0denen Sie verwenden können Exception FiltersSyntax , die bereits von der CLR in Vorschauen Versionen unterstützt wurde , aber gab es nur in VB.NET/ MSIL:

try
{
    WebId = new Guid(queryString["web"]);
}
catch (Exception exception) when (exception is FormatException || ex is OverflowException)
{
    WebId = Guid.Empty;
}

Dieser Code fängt den Exceptioneinzigen ab, wenn es sich um ein InvalidDataExceptionoder handelt ArgumentNullException.

Tatsächlich können Sie grundsätzlich jede Bedingung in diese whenKlausel einfügen:

static int a = 8;

...

catch (Exception exception) when (exception is InvalidDataException && a == 8)
{
    Console.WriteLine("Catch");
}

Beachten Sie, dass im Gegensatz zu einer ifAnweisung im catchGültigkeitsbereich des Bereichs Exception Filtersnicht geworfen werden Exceptionskann. Wenn dies trueder catchFall ist oder wenn die Bedingung nicht erfüllt ist , wird stattdessen die nächste Bedingung ausgewertet:

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

Ausgabe: Allgemeiner Fang.

Wenn es mehr als eine gibt, wird true Exception Filterdie erste akzeptiert:

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

Ausgabe: Fang.

Und wie Sie im MSILCode sehen können, wird der Code nicht in ifAnweisungen übersetzt , sondern in Filtersund Exceptionskann nicht aus den mit Filter 1und gekennzeichneten Bereichen Filter 2geworfen Exceptionwerden, aber der Filter, der den Code auslöst , schlägt stattdessen fehl, auch der letzte Vergleichswert, der vor dem endfilterBefehl auf den Stapel verschoben wurde bestimmt den Erfolg / Misserfolg des Filters ( Catch 1 XOR Catch 2 wird entsprechend ausgeführt):

Hat auch speziell Guiddie Guid.TryParseMethode.

Mit C # 7 kann die Antwort von Michael Stum verbessert werden, während die Lesbarkeit einer switch-Anweisung erhalten bleibt :

catch (Exception ex)
{
    switch (ex)
    {
        case FormatException _:
        case OverflowException _:
            WebId = Guid.Empty;
            break;
        default:
            throw;
    }
}

Und mit C # 8 als Schalterausdruck:

catch (Exception ex)
{
    WebId = ex switch
    {
        _ when ex is FormatException || ex is OverflowException => Guid.Empty,
        _ => throw ex
    };
}

Die akzeptierte Antwort scheint akzeptabel zu sein, außer dass CodeAnalysis / FxCop sich über die Tatsache beschwert, dass ein allgemeiner Ausnahmetyp abgefangen wird.

Es scheint auch, dass der Operator "is" die Leistung geringfügig beeinträchtigen könnte.

CA1800: Cast nicht unnötig sagt, dass "stattdessen das Ergebnis des Operators 'as' getestet werden soll", aber wenn Sie dies tun, schreiben Sie mehr Code, als wenn Sie jede Ausnahme einzeln abfangen.

Jedenfalls würde ich Folgendes tun:

bool exThrown = false;

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

if (exThrown)
{
    // Something else
}

In C # 6 wird empfohlen, Ausnahmefilter zu verwenden. Hier ein Beispiel:

 try
 {
      throw new OverflowException();
 }
 catch(Exception e ) when ((e is DivideByZeroException) || (e is OverflowException))
 {
       // this will execute iff e is DividedByZeroEx or OverflowEx
       Console.WriteLine("E");
 }

Dies ist eine Variante von Matts Antwort (ich denke, das ist ein bisschen sauberer) ... benutze eine Methode:

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

    WebId = Guid.Empty;
}

Alle anderen Ausnahmen werden ausgelöst und der Code WebId = Guid.Empty;wird nicht getroffen. Wenn Sie nicht möchten, dass andere Ausnahmen Ihr Programm zum Absturz bringen, fügen Sie dies NACH den beiden anderen Fängen hinzu:

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

Joseph Daigles Antwort ist eine gute Lösung, aber ich fand die folgende Struktur etwas aufgeräumter und weniger fehleranfällig.

catch(Exception ex)
{   
    if (!(ex is SomeException || ex is OtherException)) throw;

    // Handle exception
}

Das Invertieren des Ausdrucks bietet einige Vorteile:

• Eine return-Anweisung ist nicht erforderlich
• Der Code ist nicht verschachtelt
• Es besteht kein Risiko, die 'throw'- oder' return'-Aussagen zu vergessen, die in Josephs Lösung vom Ausdruck getrennt sind.

Es kann sogar zu einer einzigen Zeile komprimiert werden (obwohl nicht sehr hübsch)

catch(Exception ex) { if (!(ex is SomeException || ex is OtherException)) throw;

    // Handle exception
}

Bearbeiten: Die Ausnahmefilterung in C # 6.0 macht die Syntax etwas sauberer und bietet gegenüber jeder aktuellen Lösung eine Reihe weiterer Vorteile . (vor allem den Stapel unversehrt lassen)

So würde das gleiche Problem mit der C # 6.0-Syntax aussehen:

catch(Exception ex) when (ex is SomeException || ex is OtherException)
{
    // Handle exception
}

@ Michael

Leicht überarbeitete Version Ihres Codes:

catch (Exception ex)
{
   Type exType = ex.GetType();
   if (exType == typeof(System.FormatException) || 
       exType == typeof(System.OverflowException)
   {
       WebId = Guid.Empty;
   } else {
      throw;
   }
}

String-Vergleiche sind hässlich und langsam.

Wie wäre es mit

try
{
    WebId = Guid.Empty;
    WebId = new Guid(queryString["web"]);
}
catch (FormatException)
{
}
catch (OverflowException)
{
}

catch (Exception ex)
{
    if (!(
        ex is FormatException ||
        ex is OverflowException))
    {
        throw;
    }
    Console.WriteLine("Hello");
}

Vorsicht und Warnung: Noch ein anderer, funktionaler Stil.

Was in dem Link enthalten ist, beantwortet Ihre Frage nicht direkt, aber es ist trivial, sie so zu erweitern, dass sie aussieht:

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

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

(Grundsätzlich eine weitere leere CatchÜberladung bereitstellen, die sich selbst zurückgibt)

Die größere Frage dazu ist warum . Ich denke nicht, dass die Kosten den Gewinn hier überwiegen :)

Update 15.12.2015: Siehe https://stackoverflow.com/a/22864936/1718702 C # 6 finden . Es ist sauberer und jetzt Standard in der Sprache.

Ausgerichtet für Menschen, die eine elegantere Lösung suchenIch bin , um einmal zu fangen und Ausnahmen zu filtern. Ich verwende eine Erweiterungsmethode, wie unten gezeigt.

Ich hatte diese Erweiterung bereits in meiner Bibliothek, die ursprünglich für andere Zwecke geschrieben wurde, aber sie funktionierte perfekt type, um Ausnahmen zu überprüfen. Außerdem sieht es imho sauberer aus als eine Reihe von ||Aussagen. Im Gegensatz zur akzeptierten Antwort bevorzuge ich auch die explizite Ausnahmebehandlung, sodass ich ein ex is ...unerwünschtes Verhalten hatte, da abgeleitete Klassen den übergeordneten Typen zugewiesen werden können.

Verwendungszweck

if (ex.GetType().IsAnyOf(
    typeof(FormatException),
    typeof(ArgumentException)))
{
    // Handle
}
else
    throw;

IsAnyOf.cs-Erweiterung (Abhängigkeiten siehe Beispiel für die vollständige Fehlerbehandlung)

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

Beispiel für die vollständige Fehlerbehandlung (Kopieren, Einfügen in neue Konsolen-App)

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

Zwei Beispiel-NUnit-Unit-Tests

Das Übereinstimmungsverhalten für ExceptionTypen ist genau (dh ein Kind ist KEINE Übereinstimmung für einen seiner übergeordneten Typen).

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*/
            }
        }
    }
}

Da ich das Gefühl hatte, dass diese Antworten nur die Oberfläche berührten, versuchte ich etwas tiefer zu graben.

Was wir also wirklich tun möchten, ist etwas, das nicht kompiliert werden kann, sagen wir:

// Won't compile... damn
public static void Main()
{
    try
    {
        throw new ArgumentOutOfRangeException();
    }
    catch (ArgumentOutOfRangeException)
    catch (IndexOutOfRangeException) 
    {
        // ... handle
    }

Der Grund, warum wir dies wollen, ist, dass wir nicht möchten, dass der Ausnahmebehandler Dinge abfängt, die wir später im Prozess benötigen. Sicher, wir können eine Ausnahme abfangen und mit einem "Wenn" prüfen, was zu tun ist, aber seien wir ehrlich, das wollen wir nicht wirklich. (FxCop, Debugger-Probleme, Hässlichkeit)

Warum wird dieser Code nicht kompiliert - und wie können wir ihn so hacken, dass er es tut?

Wenn wir uns den Code ansehen, möchten wir den Anruf wirklich weiterleiten. Gemäß der MS-Partition II funktionieren IL-Ausnahmebehandlungsblöcke jedoch nicht so, was in diesem Fall sinnvoll ist, da dies bedeuten würde, dass das 'Ausnahme'-Objekt unterschiedliche Typen haben kann.

Oder um es in Code zu schreiben, bitten wir den Compiler, so etwas zu tun (nun, es ist nicht ganz richtig, aber es ist das nächstmögliche, was ich denke):

// Won't compile... damn
try
{
    throw new ArgumentOutOfRangeException();
}
catch (ArgumentOutOfRangeException e) {
    goto theOtherHandler;
}
catch (IndexOutOfRangeException e) {
theOtherHandler:
    Console.WriteLine("Handle!");
}

Der Grund, warum dies nicht kompiliert werden kann, liegt auf der Hand: Welchen Typ und Wert hätte das Objekt '$ exception' (die hier in den Variablen 'e' gespeichert sind)? Der Compiler soll damit umgehen, indem er feststellt, dass der gemeinsame Basistyp beider Ausnahmen "Ausnahme" ist. Verwenden Sie diesen Typ für eine Variable, die beide Ausnahmen enthält, und behandeln Sie dann nur die beiden abgefangenen Ausnahmen. Die Art und Weise, wie dies in IL implementiert wird, ist als 'Filter', der in VB.Net verfügbar ist.

Damit es in C # funktioniert, benötigen wir eine temporäre Variable mit dem richtigen Basistyp 'Exception'. Um den Codefluss zu steuern, können wir einige Zweige hinzufügen. Hier geht:

    Exception ex;
    try
    {
        throw new ArgumentException(); // for demo purposes; won't be caught.
        goto noCatch;
    }
    catch (ArgumentOutOfRangeException e) {
        ex = e;
    }
    catch (IndexOutOfRangeException e) {
        ex = e;
    }

    Console.WriteLine("Handle the exception 'ex' here :-)");
    // throw ex ?

noCatch:
    Console.WriteLine("We're done with the exception handling.");

Die offensichtlichen Nachteile dafür sind, dass wir nicht richtig zurückwerfen können und - seien wir ehrlich - dass es eine ziemlich hässliche Lösung ist. Die Hässlichkeit kann ein wenig behoben werden, indem eine Verzweigungseliminierung durchgeführt wird, wodurch die Lösung etwas besser wird:

Exception ex = null;
try
{
    throw new ArgumentException();
}
catch (ArgumentOutOfRangeException e)
{
    ex = e;
}
catch (IndexOutOfRangeException e)
{
    ex = e;
}
if (ex != null)
{
    Console.WriteLine("Handle the exception here :-)");
}

Das lässt nur den "Neuwurf". Damit dies funktioniert, müssen wir in der Lage sein, die Behandlung innerhalb des 'catch'-Blocks durchzuführen - und die einzige Möglichkeit, dies zu erreichen, ist ein abfangendes' Exception'-Objekt.

An dieser Stelle können wir eine separate Funktion hinzufügen, die die verschiedenen Arten von Ausnahmen mithilfe der Überlastungsauflösung oder zur Behandlung der Ausnahme behandelt. Beide haben Nachteile. Hier ist der Weg, um dies mit einer Hilfsfunktion zu tun:

private static bool Handle(Exception e)
{
    Console.WriteLine("Handle the exception here :-)");
    return true; // false will re-throw;
}

public static void Main()
{
    try
    {
        throw new OutOfMemoryException();
    }
    catch (ArgumentException e)
    {
        if (!Handle(e)) { throw; }
    }
    catch (IndexOutOfRangeException e)
    {
        if (!Handle(e)) { throw; }
    }

    Console.WriteLine("We're done with the exception handling.");

Die andere Lösung besteht darin, das Exception-Objekt abzufangen und entsprechend zu behandeln. Die wörtlichste Übersetzung hierfür, basierend auf dem obigen Kontext, lautet:

try
{
    throw new ArgumentException();
}
catch (Exception e)
{
    Exception ex = (Exception)(e as ArgumentException) ?? (e as IndexOutOfRangeException);
    if (ex != null)
    {
        Console.WriteLine("Handle the exception here :-)");
        // throw ?
    }
    else 
    {
        throw;
    }
}

Also zum Schluss:

• Wenn wir nicht erneut werfen möchten, können wir erwägen, die richtigen Ausnahmen abzufangen und sie vorübergehend zu speichern.
• Wenn der Handler einfach ist und wir Code wiederverwenden möchten, besteht die beste Lösung wahrscheinlich darin, eine Hilfsfunktion einzuführen.
• Wenn wir erneut werfen möchten, haben wir keine andere Wahl, als den Code in einen Catch-Handler "Exception" zu setzen, wodurch FxCop und die nicht erfassten Ausnahmen Ihres Debuggers beschädigt werden.

Dies ist ein klassisches Problem, mit dem jeder C # -Entwickler irgendwann konfrontiert ist.

Lassen Sie mich Ihre Frage in zwei Fragen aufteilen. Der Erste,

Kann ich mehrere Ausnahmen gleichzeitig abfangen?

Kurz gesagt, nein.

Was zur nächsten Frage führt:

Wie vermeide ich das Schreiben von doppeltem Code, da ich nicht mehrere Ausnahmetypen im selben catch () -Block abfangen kann?

In Anbetracht Ihrer spezifischen Stichprobe, bei der der Fallback-Wert günstig zu konstruieren ist, möchte ich die folgenden Schritte ausführen:

1. Initialisieren Sie WebId mit dem Fallback-Wert.
2. Erstellen Sie eine neue Guid in einer temporären Variablen.
3. Setzen Sie WebId auf die vollständig erstellte temporäre Variable. Machen Sie dies zur endgültigen Anweisung des try {} -Blocks.

Der Code sieht also so aus:

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

Wenn eine Ausnahme ausgelöst wird, wird WebId niemals auf den halb konstruierten Wert gesetzt und bleibt Guid.Empty.

Wenn das Erstellen des Fallback-Werts teuer und das Zurücksetzen eines Werts viel billiger ist, würde ich den Rücksetzcode in eine eigene Funktion verschieben:

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

Sie wiederholen also viel Code in jedem Ausnahmeschalter? Klingt so, als wäre das Extrahieren einer Methode eine gute Idee, nicht wahr?

Ihr Code läuft also auf Folgendes hinaus:

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 */ }

Ich frage mich, warum niemand diese Codeduplizierung bemerkt hat.

Ab C # 6 haben Sie außerdem die Ausnahmefilter, wie bereits von anderen erwähnt. So können Sie den obigen Code folgendermaßen ändern:

try { ... }
catch(Exception e) when(e is Exception1 || e is Exception2)
{ 
    Reset(instance); 
}

Wollte meine kurze Antwort zu diesem bereits langen Thread hinzufügen. Was nicht erwähnt wurde, ist die Rangfolge der catch-Anweisungen. Insbesondere müssen Sie den Umfang jeder Art von Ausnahme kennen, die Sie abfangen möchten.

Wenn Sie beispielsweise eine "catch-all" -Ausnahme als Ausnahme verwenden , geht sie allen anderen catch-Anweisungen voraus, und Sie erhalten offensichtlich Compilerfehler. Wenn Sie jedoch die Reihenfolge umkehren, können Sie Ihre catch-Anweisungen verketten (ein bisschen ein Anti-Pattern, denke ich ) Sie können den Catch-All- Ausnahmetyp unten einfügen. Dadurch werden alle Ausnahmen erfasst, die in Ihrem try..catch-Block nicht berücksichtigt wurden:

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

Ich empfehle den Leuten dringend, dieses MSDN-Dokument zu lesen:

Ausnahmehierarchie

Versuchen Sie vielleicht, Ihren Code einfach zu halten, z. B. den allgemeinen Code in eine Methode einzufügen, wie Sie es in jedem anderen Teil des Codes tun würden, der nicht in einer catch-Klausel enthalten ist?

Z.B:

try
{
    // ...
}
catch (FormatException)
{
    DoSomething();
}
catch (OverflowException)
{
    DoSomething();
}

// ...

private void DoSomething()
{
    // ...
}

Wie ich es machen würde, wenn ich versuche, das Einfache zu finden, ist ein schönes Muster

Beachten Sie, dass ich einen Weg gefunden habe, dies zu tun, aber dies sieht eher nach Material für The Daily WTF aus :

catch (Exception ex)
{
    switch (ex.GetType().Name)
    {
        case "System.FormatException":
        case "System.OverflowException":
            WebId = Guid.Empty;
            break;
        default:
            throw;
    }
}

Erwähnenswert ist hier. Sie können auf mehrere Kombinationen reagieren (Ausnahmefehler und Ausnahmemeldung).

Beim Versuch, ein Steuerobjekt in ein Datagrid mit Inhalten wie TextBox, TextBlock oder CheckBox umzuwandeln, ist ein Anwendungsszenario aufgetreten. In diesem Fall war die zurückgegebene Ausnahme dieselbe, aber die Nachricht variierte.

try
{
 //do something
}
catch (Exception ex) when (ex.Message.Equals("the_error_message1_here"))
{
//do whatever you like
} 
catch (Exception ex) when (ex.Message.Equals("the_error_message2_here"))
{
//do whatever you like
} 

Ich möchte die kürzeste Antwort vorschlagen (ein weiterer funktionaler Stil ):

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

Dazu müssen Sie mehrere "Catch" -Methodenüberladungen erstellen, ähnlich wie bei 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));
    }

und so weiter so viele wie du willst. Sie müssen es jedoch einmal ausführen und können es in all Ihren Projekten verwenden (oder wenn Sie ein Nuget-Paket erstellt haben, können wir es auch verwenden).

Und CatchMany-Implementierung:

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

ps Ich habe keine Nullprüfungen für die Einfachheit des Codes durchgeführt. Erwägen Sie, Parameterüberprüfungen hinzuzufügen.

ps2 Wenn Sie einen Wert aus dem catch zurückgeben möchten, müssen Sie dieselben Catch-Methoden ausführen, jedoch mit return und Func anstelle von Action in Parametern.

Rufen Sie einfach den Versuch an und fangen Sie zweimal.

try
{
    WebId = new Guid(queryString["web"]);
}
catch (FormatException)
{
    WebId = Guid.Empty;
}
try
{
    WebId = new Guid(queryString["web"]);
}
catch (OverflowException)
{
    WebId = Guid.Empty;
}

So einfach ist das !!

In c # 6.0 sind Ausnahmefilter Verbesserungen für die Ausnahmebehandlung

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