Geworfene Exceptions allgemein weiterwerfen

Ich weiß, der Titel ist etwas komisch.
Ich würde gern folgendes wissen: Kann ich, wenn eine Funktion eine von mehreren möglichen Exceptions wirft, diese allgemein weiterwerfen, ohne explizit jede Version selbst zu deklarieren?

Ein Beispiel: Wir haben eine vordefinierte Funktion F. Diese Funktion kann unterschiedliche Exceptions werfen, welche ich in meiner eigenen Funktion M nicht selbst behandeln will, sondern ich benutze selbst ein throw. Kann ich nun etwas machen, was folgendem ähnelt:

void M()
{
    throw F();
}

oder muss ich den umständlichen Weg gehen:

void M()
{
    try
    {
        F();
    }
    catch(OutOfBoundsException ex)
    {
        throw ex;
    }
    catch(DivisionByZeroException ex)
    {
        throw ex;
    }
    catch(StackOverflowException ex)
    {
        throw ex;
    }
    catch(NullPointerException ex)
    {
        throw ex;
    }
    //...
}

Meine Funktion M soll also in der Lage sein, automatisch jede Exception weiterzuleiten, die F wirft, und zwar mit den spezifischen Klassennamen, also nicht einfach nur eine generelle Ausnahme vom Typ Exception. Geht sowas?

Musst du sie überhaupt fangen?
Ansonsten kommt man über irgendwelche Reflectiontricks bestimmt auch an den Typ bei der allgemeinen Variante.

SeboStone

catch(Exception ex) ist die Lösung. Exception ist die oberste Klasse, da läuft alles rein.

Edit:

Ah, habe den letzten Teil nicht gelesen. Schau Dir mal die InnerExeption an und Exeption.ToString. Soweit ich mich erinnere steht da noch einiges mehr drin, so dass Du den Klassennamen eigentlich gar nicht brauchst.

Wieso willst du die Expetion überhaupt weiterwerfen?

Wenn du sie nicht behandelst wird sie automatisch an die im callstack nächst höhere Prozedur weitergegeben. So lange bis sie bei der Runtime landet, was dann in der schönen uns allen bekannten Fehlermeldung resultiert.

Wieso willst du die Expetion überhaupt weiterwerfen?

Wenn du sie nicht behandelst wird sie automatisch an die im callstack nächst höhere Prozedur weitergegeben. So lange bis sie bei der Runtime landet, was dann in der schönen uns allen bekannten Fehlermeldung resultiert.

Stimmt ja eigentlich: Wenn ich einen Wrapper um eine oder mehrere Funktion schreibe, kann ich auf das try-catch komplett verzichten und die Funktion, die meine Funktion aufruft, kann die Exceptions genauso auffangen, als hätte sie die ursprüngliche Funktion aufgerufen.
Danke für den Hinweis.

Konrad Rudolph

Man wirft Ausnahmen nicht mit throw ex; weiter! Dazu ist (genau wie in C++) throw; da.

Konrad Rudolph schrieb:

Man wirft Ausnahmen nicht mit throw ex; weiter! Dazu ist (genau wie in C++) throw; da.

Mal so aus neugierde, wo ist denn der unterschied zwischen:

try
{
}
catch (Exception ex)
{
    throw ex;
}

und

try
{
}
catch
{
    throw;
}

Shade Of Mine

throw;
wirft die Exception weiter.

throw ex;
wirft eine neue Exception.

Das wird vorallem dann interessant wenn einem der Stacktrace interessiert. (Bei throw ex; wird der alte Stacktrace weggeworfen, da man die exception ja gefangen hat, ergo behandelt hat. Bei throw; wird der stacktrace aber behalten, da die exception noch nicht behandelt wurde). Generell macht es deshalb keinen Sinn throw ex zu schreiben. Wenn man eine neue Exception werfen will, dann wohl eher gleich einen neuen typen:
throw new SomeException(ex);
Dafuer hat man ja Exception Chaining.