Best Practice: Exceptions

Hi,

mich würde mal interessieren wie Ihr mit Exceptions umgeht.

z.B. ich lösche eine Datei.

Da gibt es ja verschiedene Exceptions.

Fragt Ihr jede mögliche Exceptions ab ?

Gruß

rockthecity

Hi!

Die beste Fehlerbehandlung ist jede Exception auf irgendeine Art zu behandeln. Exceptions, bei denen ich weiß, dass sie auf mit hoher Wahrscheinlichkeit auftreten und den Programmablauf stören können, fange ich einzeln ab und behandle sie. Die übrigbleibenden fange ich anschließend mit einem catch(Exception ex) und behandle sie allgemein (Standardfehlerroutine, Fehlermeldung, etc...)

der Marcel

Nur die, die man erwartet! Man sollte niemals am Anfang an schon generisch alle Exceptions abfangen, weil dann auch Exceptions flöten gehen die man gar nicht erwartet und dann hat man doch nen undefinierten Zustand obwohl man den durchs Exceptionhandling ja verhindern wollte.

Danke schonmal für die Antworten.

Schreibt für eure Klassen immer eigene Exception Klassen ?

Hi talla!

Beim Debuggen ist es wirklich nicht sinnvoll schon jede Exception auf jeden Fall zu fangen. Wenn das Programm aber anscheinend fertig ist, kann man durchaus alle abfangen um die Fehlermeldungen etwas benutzerfreundlicher zu gestalten (nur die Message und den Typ ausgeben).

der Marcel

EDIT: @rockthecity: bei Framework-Bibliotheken nicht. Bei eigenen Klassen könnte man darüber nachdenken, wenn das Framework keine passende Exception-Klasse bereitstellt, die man werfen kann.

Super vielen Dank.

Die Frage ist eigentlich nicht OB man Exceptions fängt, sondern WO. Und das ist mitunter eine schwierige Frage. In jedem Fall an den Komponentengrenzen.

Hallo talla,

Nur die, die man erwartet! Man sollte niemals am Anfang an schon generisch alle Exceptions abfangen, weil dann auch Exceptions flöten gehen die man gar nicht erwartet und dann hat man doch nen undefinierten Zustand obwohl man den durchs Exceptionhandling ja verhindern wollte.

während der Entwicklung könnte ich das vorgehen verstehen. Für die Release-Version gar nicht! Im Sinne der robusten Programmierung sollte man auch mit unerwarteten Situationen möglichst sinnvoll umgehen.

herbivore

Schon, ich wollte damit eher ausdrücken das man eher explizit auf bestimmte Exceptions wartet, als einfach generisch alle Abzufangen

Hallo talla,

ich wollte damit auch nur sagen, dass ich eher alle Exceptions generisch abfange statt explizit auf bestimmte Exceptions zu warten. 🙂

herbivore

Also ich persönlich fange nicht alle Exceptions ab, sondern hab nur eine allgemeine Fehlerbehandlung.

D.h. nur ein catch(Exception ex). Dort protokolliere ich den Fehler in einer Datei und leite den User auf eine Fehlerseite weiter (Web). Win-Applikationen programmiere ich noch nicht. Würde da aber vielleicht auch so ähnlich erfahren.

Original von plongo
Also ich persönlich fange nicht alle Exceptions ab...

D.h. nur ein catch(Exception ex). ...

Du fängst damit doch jede Exception ab 😁
So wie ich Herbivore verstanden hab macht er es auch eher so generisch wie du. Ich dagegen würde vorher lieber die einzelnen verschiedenen Exceptions abfangen da evtl. unterschiedlich drauf reagiert werden muss, und dann zum Schluss noch ne allgemeine Fehlerbehandlung ranhängen, falls was arg unerwartetes auftritt.

sorry, das habe ich gemeint. Blöd ausgedrückt. Gut momenten benötige ich es nocht nicht auf die verschiedenen Exceptions zu reagieren. Wie ich es momentan habe klappt es wunderbar. Nur bein wenigen habe ich mehrer Fehlerbehandlungen drin.

Original von talla
Schon, ich wollte damit eher ausdrücken das man eher explizit auf bestimmte Exceptions wartet, als einfach generisch alle Abzufangen

Das ist sicher auch vom Stil her besser. Es gibt nur leider Situationen wo das schwer wird.
Es ist sicher besser einfach alle Exceptions abzufangen und zu loggen, als das sich das Programm einfach mit ner unbehandelten Exception verabschiedet (und damit möglicherweise noch mehr Schaden anrichtet)!!

Hi!

Wenn ich talla richtig verstanden habe, sind wir der selben Aufassung. Sollten einige Exceptions vorhersehbar sein, werden diese abgefangen und behandelt. Zum Schluss wird ein generisches Exception-Handling mit catch(Exception ex) angehangen um auch auf unvorhergesehene Fehler zu reagieren.
Falls keine vorhersehbar sind, fällt Schritt 1 natürlich raus und man macht nur ein generisches Exception-Handling.

der Marcel

Das sollte man aber nur auf der untersten Ebene machen. Dann, wenn das Programm wirklich am abschmieren ist und die Exception nicht weiter nach unten gereicht werden kann. Alles andere ist very bad practice.

Dazu gibts ja sogar in der AppDomain noch das Event UnhandledException. Da gehört sowas eigentlich rein. Prinzipiell in Funktionen jede Exception abzufangen ist absolut nicht empfehlenswert. Klar soll das Programm gut aussehen. Aber das fällt einem mit Sicherheit auf die Füße, wenn man das Programm irgendwann mal wieder erweitern will. Man stelle sich mal vor beim Framework hätten die so gearbeitet. Dann würde da nichts mehr ne Exception werfen. Damit wär das ganze absolut unbrauchbar.

Von nem catch, log und rethrow halte ich genauso wenig. Exceptions führen selbstständig nen Stacktrace mit, also reichts wenn man sie einmal am Ende logt.

Es gibt 4 Gründe eine Exception abzufangen:

1. man fängt eine bestimmte Exception ab, weil man damit rechnet
2. man fängt eine bestimmte Exception ab, weil man sie behandeln kann
3. man fängt alle Exceptions ab, weil man noch zusätzliche Informationen hinzugeben kann, und wirft dann eine neue Exception mit der Alten als InnerException
4. man fängt alle Exceptions ab, weil es für das restliche Programm absolut ohne Auswirkungen ist

Mit am Schluss mein ich auch nicht unbedingt gleich hinterm letzten Catch das ne spezielle Exception abfängt. Die Application Klasse bietet ja das Event ThreadException wo man sich prima ranhängen kann um einen globalen Exceptionhandler für nen Programm zu installieren. Das ganze ist aber nur praktikabel wenn man davon ausgeht, dass unbehandelte Exceptions in den Funktionen zu keinen Fehlern führen und man global was loggen will etc. Ansonsten muss man nämlich von ausgehen, sobald der globale Exception Handler aufgerufen wird, das das ganze Programm am Arsch ist und man es lieber beenden sollte.

Hallo zusammen,

ich kann die Sichtweise, nur bestimmte Exceptions zu fangen, nicht verstehen.

Nehmen wir mal einen EventHandler für MenuItem.Click. Da würde ich natürlich ein try/catch für beliebige Exceptions rumpacken und dem Benutzer eine entsprechende Meldung anzeigen.

Dass ein Programm in einem ungeregelten Zustand ist, nur weil eine Exception auftritt, mit der ich nicht gerechnet habe, halte ich für unwahrscheinlich oder für ein Zeichen schlechten Programmierstils. Zumindest kann man überhaupt nicht davon ausgehen, dass ein Programm im Arsch, nur weil eine unbekannte Exception aufgetreten ist. Natürlich muss man in jedem catch dafür sorgen, dass sauber aufgeräumt wird. Dieses Aufräumen ist aber in der Regel unabhängig von der konkreten Exception möglich.

herbivore

Nun stell dir mal vor du verwendest die Funktion irgendwo wieder.
Woran merkst du, dass da was nicht geklappt hat? Garnicht. Oder willst du zurück ins Mittelalter zu Fehlercodes, die mühsam weiter nach unten gereicht werden können, oder einem statischen GetLastError()?

Wie gesagt auf unterster Ebene, wenn das Programm vorm Beenden steht, noch ne Fehlermeldung rauszuhauen und alle Exceptions zu fangen ist ok. Alles andere ist einfach unbrauchbar.

Hi herbivore!

Was ist, wenn ich weiß, dass eine bestimmte Exception auf jeden Fall auftreten kann? Zum Beispiel, dass beim Zugriff auf eine Datei der Zugriff verweigert wird? Dann möchte man doch vielleicht gar nicht die Standardfehlerroutine durchlaufen, sondern das Problem eleganter behandeln, oder?

der Marcel

Hallo Traumzauberbaum,

Nun stell dir mal vor du verwendest die Funktion irgendwo wieder.
Woran merkst du, dass da was nicht geklappt hat? Garnicht. Oder willst du zurück ins Mittelalter zu Fehlercodes, die mühsam weiter nach unten gereicht werden können, oder einem statischen GetLastError()?

ganz schön polemisch. Ich habe nicht gesagt, dass ich alle Exceptions wegfangen will, ich habe nur gesagt, dass wenn ich Exceptions fange, (nahezu) immer alle Exceptions fange.

Wie gesagt auf unterster Ebene, wenn das Programm vorm Beenden steht, noch ne Fehlermeldung rauszuhauen und alle Exceptions zu fangen ist ok. Alles andere ist einfach unbrauchbar.

Ich denke du verwechselst oberste und unterste Ebene. Aber bis zur obersten Ebene (= Main) zu warten, wäre falsch. Normalerweise sind die EventHandler für Benutzeraktionen die Ebene der Wahl, um alles wegzufangen (und anzuzeigen).

Auch auf drunter liegenden Ebenen fange ich alle Exceptions, um aufräumen, aber dann gibt es natürlich ein rethrow.

Hallo der Marcel,

der Fall ist möglich, auch sinnvoll, aber meine Erfahrung nach einfach sehr selten.

herbivore

Original von herbivore
ganz schön polemisch. Ich habe nicht gesagt, dass ich alle Exceptions wegfangen will, ich habe nur gesagt, dass wenn ich Exceptions fange, (nahezu) immer alle Exceptions fange.

Und das ist eben eines der Probleme die ich mit der Antwort habe. Wenn nach "best practice" gefragt wird, solltest du nicht nur schreiben was du tust, sondern auch was du nicht tust. Und du hast eben nur geschrieben, dass es ok ist alle Exceptions abzufangen. Du hast nicht geschrieben, wann man das lassen sollte.
Das reicht eben nicht aus um den Sachverhalt voll zu beleuchten.

Original von herbivore
Ich denke du verwechselst oberste und unterste Ebene. Aber bis zur obersten Ebene (= Main) zu warten, wäre falsch. Normalerweise sind die EventHandler für Benutzeraktionen die Ebene der Wahl, um alles wegzufangen (und anzuzeigen).

Auch auf drunter liegenden Ebenen fange ich alle Exceptions, um aufräumen, aber dann gibt es natürlich ein rethrow.

Hier wieder ein schönes Beispiel dafür, wie weglassen von Informationen zu nem völlig falschen Bild führt. Es reicht eben nicht zu sagen man fängt alles. Die Einschränkungen unter denen man es tut sind enorm wichtig.
Bei EventHandlern für Benutzeraktionen. Vollkommen in Ordnung. Was nun oben oder unten ist, lass ich mal dahingestellt. Ich hab ja erklärt was ich damit meine. In der Informatik hat der Baum seine Wurzel oben und seine Blätter unten, und ein Stack wächst von unten nach oben.
Oder eben du wirfst die Exception weiter. Hast du auch nicht gesagt. Ist auch wichtig.

Diese Informationen kannst du nicht einfach weglassen. Das du das ordentlich machst glaub ich dir ja sogar, sonst wärst hier bestimmt nicht Moderator. Aber du sagst es eben nicht vollständig und das lässt ein falsches Bild entstehen. Man stellt ja solche Fragen nicht um zu überprüfen ob die anderen das auch wissen.

Ich meine der Unterschied zu den Einschränkungen und Bedingungen die du jetzt erst formulierst und dem hier muss doch auch dir deutlich sein

ich wollte damit auch nur sagen, dass ich eher alle Exceptions generisch abfange statt explizit auf bestimmte Exceptions zu warten. 🙂

Das ist genau das Problem was viele mit hinreichender und notwendiger Bedingung haben.
Das ist wie zu sagen "Ich fahre immer die maximale erlaubte Geschwindigkeit". Es ist also notwendig, dass die Geschwindigkeit erlaubt ist, damit ich die Geschwindigkeit Fahre. Gleichzeitig impliziere ich damit aber, dass wenn die Geschwindigkeit erlaub ist, fahre ich sie auch. Real siehen die hinreichenden Bedingungen aber anders aus. Wenn es Wetter, Straßenverhältnisse oder Leistung des Autos nicht zulassen, dann fahr ich eben nicht so schnell. Du hast quasi Letzteres einfach mal weggelassen und der Fahranfänger glaubt nun, er sollte immer das Maximum fahren.

Hallo Traumzauberbaum,

die Ausgangsfrage war:

z.B. ich lösche eine Datei. Da gibt es ja verschiedene Exceptions. Fragt Ihr jede mögliche Exceptions ab ?

Darauf habe ich (indirekt) geantwortet. Es ging ja nicht darum, wo man überall Exceptions abfängt und schon gar nicht wegfängt, sondern wenn man welche fängt, ob alle oder bestimmte. Das scheinst du in den falschen Hals bekommen zu haben. Es ging zu keiner Zeit um das Wegfangen von allen Exceptions an allen Stellen. Deshalb hatte ich es auch nicht für nötig befunden, dass explizit zu schreiben. Aber es hat sich ja gekärt.

Nun stell dir mal vor du verwendest die Funktion irgendwo wieder.
Woran merkst du, dass da was nicht geklappt hat? Garnicht. Oder willst du zurück ins Mittelalter zu Fehlercodes, die mühsam weiter nach unten gereicht werden können, oder einem statischen GetLastError()?

Schon an den von dir beschrieben Auswirkungen, wenn man an allen Stellen alle Exceptions fängt, hätte klar sein sollen, dass diese Interperation meine Ausage unsinnig ist.

Zur obersten und untersten Ebene: In der guten halten Zeit hieß das, was jetzt Methode heißt, Unterprogramm. Außerdem gibt es die Programmiertechniken Top-Down und Bottom-Up. Alleine durch diese beiden Tatsachen ist ziemlich definiert, wo in einem Programm oben und unten ist. 🙂

herbivore