Fra magasinetema til prosjektpraksis
Egnede tjeneste- og tekniske sider for innlegget
Der Fehler kommt nicht im Debugger, sondern als Ticket aus dem Betrieb: „Speichern fehlgeschlagen“. Der Logeintrag zeigt eine Exception – und als Ursprung steht ausgerechnet der except-Block, in dem eigentlich nur aufgeräumt und „durchgereicht“ werden sollte. Wer dann in den Code springt, findet oft dieselbe Mini-Entscheidung an mehreren Stellen: raise; oder raise E;. Und genau hier entscheidet sich, ob ihr später den echten Ursprung findet oder euch an einer künstlich verschobenen Spur festbeißt.
Dieser Praxisleitfaden zielt auf ein klares Ergebnis: Delphi Exception-Stacktrace sauber durchreichen, ohne Nebenwirkungen. Wir gehen über eine schnelle Prüfung, treffen eine saubere Auswahl je Schicht, setzen ein robustes Muster um, räumen typische Fehler aus dem Weg und benennen Punkte, an denen ein kontrollierter Abbruch oder eine Eskalation fachlich richtiger ist als „irgendwie weiter“.
Prüffrage zuerst: Re-Raise oder bewusstes Wrapping?
Bevor du an Syntax drehst, klär die Absicht. In der Praxis gibt es zwei sehr unterschiedliche Situationen, die im Code leider oft gleich behandelt werden:
- Re-Raise (weiterwerfen): Du fängst eine Exception, machst Cleanup oder Logging und willst anschließend genau dieselbe Exception wieder nach oben geben. Ziel: Diagnosefähigkeit erhalten, Ursprung nicht verfälschen.
- Wrapping/Übersetzung: Du willst absichtlich eine andere Exception werfen, etwa weil eine Service-Schicht keine technischen Details nach außen geben soll. Ziel: stabiler Fehlervertrag (z. B. Fehlercode), aber die Ursache intern weiterhin nachvollziehbar.
Die häufigste Ursache für „Stacktrace endet im Catch-Block“ ist, dass Re-Raise und Wrapping unbewusst vermischt werden: Man will nur weiterwerfen, baut aber faktisch ein neues Raise ein.
Delphi Exception-Stacktrace sauber durchreichen: Warum raise; die robuste Form ist
Im except-Block ist raise; die Kurzform für „wirf die aktuell behandelte Exception erneut“. Das ist genau das, was du beim Re-Raise willst: dieselbe Exception-Instanz inklusive des vorhandenen Kontextes weitergeben. Embarcadero dokumentiert dieses Muster ausdrücklich – und warnt ebenso ausdrücklich davor, zum Re-Raise raise E; zu verwenden.[Quelle]
Praktische Konsequenz: Debugger, Crash-Reporting oder euer Logging sehen deutlich seltener die Catch-Stelle als „Ursprung“. Stattdessen bleibt die Chance hoch, dass die Fehlerstelle sichtbar bleibt, an der das Problem tatsächlich ausgelöst wurde (zum Beispiel Datenzugriff, IO, Konvertierung).
Was raise E; wirklich tut – und warum es euch Diagnose kostet
raise E; ist kein Re-Raise im Sinne von „aktuelle Exception weiterwerfen“, sondern ein erneutes Auslösen (Raise) eines konkret referenzierten Exception-Objekts. Das macht in der Tooling-Sicht schnell aus „dort ist es passiert“ ein „hier wurde es neu geworfen“. Genau dieser Effekt ist es, der Callstacks im Betrieb entwertet: Alle Fehler sehen aus, als kämen sie aus der gleichen Handvoll Handler.
Dazu kommt ein zweiter Punkt, der weniger sichtbar, aber im Fehlerfall teurer ist: Du kontrollierst die Lebensdauer des Exception-Objekts nicht. Der Handler sollte sich nicht darauf verlassen, dass eine gespeicherte Referenz (E) im Weiterwerfpfad so „dein“ Objekt ist, dass du es beliebig erneut raisen kannst. Der bekannte Beitrag „How not to re-raise an exception in Delphi“ beschreibt genau diese Falle und ordnet sie als potenziell instabil bis hin zu Access Violations ein.[Quelle]
Wichtige Grenze: Nicht jedes raise E; crasht sofort. Genau das ist das Problem. Es macht euer Fehlerverhalten vom Zufall abhängig (Compiler, Optimierung, Codepfad, Timing). Wer Betriebssicherheit ernst meint, braucht reproduzierbare Mechanik – nicht „meistens geht’s“.
Schnelltest im Code: Wo verliert ihr gerade den Ursprung?
Wenn Stacktraces auffällig oft im Catch-Block enden, musst du nicht lange rätseln. Suche systematisch nach diesen Mustern:
raise E;oderraise(E)innerhalb vonexcept- neue Exception-Instanz ohne „inner/nested cause“ (z. B.
raise ...Create(...)), obwohl eigentlich nur Kontext ergänzt werden sollte - Catch-all-Blöcke, die „zur Sicherheit“ alles fangen und dann weiterlaufen
Der letzte Punkt wirkt nicht direkt wie ein Stacktrace-Thema, ist aber im Betrieb oft der echte Brandbeschleuniger: Wenn ihr nach einer Exception im undefinierten Zustand weiterarbeitet, entstehen Folgefehler, die den ursprünglichen Fehler überlagern.
Auswahl je Schicht: Was ist „sauber“ für UI, Service und Datenzugriff?
Das Ziel „Callstack erhalten“ kollidiert in realen Systemen oft mit einem zweiten Ziel: Ein stabiler Fehlervertrag nach außen. Deshalb lohnt es sich, Regeln pro Schicht zu definieren. Nicht als Theorie, sondern als Review- und Betriebsstandard.
| Ort | Was dort zählt | Empfohlener Umgang | Typischer Fehlgriff |
|---|---|---|---|
| Datenzugriff (DB/ORM/BDE-Ablosung mit nativer Anbindung) | Rollback, Diagnose, keine Doppelbehandlung | Cleanup/Transaktion sichern, Kontext loggen, dann raise; |
Exception „schlucken“ oder als neue Message-Exception neu raisen |
| Domain/Use-Case-Schicht | fachliche Einordnung, stabile Fehlertypen | Nur wrappen, wenn die Exception die Schichtgrenze nicht sinnvoll passieren darf; Ursache behalten (nested) | Alles wrappen und dadurch echte Ursachen im Log verstecken |
| REST-/Service-Schicht | Fehlercodes, Security, Monitoring | Domänen-Exception/Fehlerobjekt, intern Logging inkl. Ursache; technisch nach außen reduzieren | SQL-/Pfad-Details ungefiltert an Clients senden |
| UI (VCL/FMX) | Benutzerführung, Supportfähigkeit | Globaler Handler: usertaugliche Meldung, technische Details ins Log; keine Catch-Teppiche in Click-Handlern | Im Button-Click fangen und nur „Fehler“ anzeigen |
| Windows- und Linux-Services/Daemon | Stabilität, Wiederanlauf, Exitcodes | Top-Level entscheiden: Task abbrechen, Service neu starten, Alarm; intern raise; korrekt halten |
Catch-all und danach „weiter“, obwohl Zustand unklar ist |
Umsetzung: Das robuste Muster „Cleanup + Kontext + Re-Raise“
Wenn du nur weiterreichen willst, ist der Ablauf simpel – aber er muss konsequent eingehalten werden, sonst entstehen wieder Sonderfälle.
- Catch nur dort, wo du wirklich handeln kannst: Rollback, Ressourcen schließen, Retry-Entscheidung. Nicht „zur Sicherheit“ überall.
- Kontext erfassen, den der Callstack nicht liefert: Operation/Use-Case, betroffene ID, Datei/Endpoint, Mandant, Request-ID (Korrelation).
- Cleanup trennen: Ressourcen gehören in
finally, Fehlerpfad inexcept. Das reduziert Nebenwirkungen. - Re-Raise korrekt: im
exceptam Enderaise;. - Top-Level entscheidet: Ganz oben wird aus „Exception“ ein Benutzerhinweis, HTTP-Status/Fehlercode oder ein kontrollierter Prozessabbruch.
Der Grund, warum sich diese Disziplin in Unternehmensanwendungen lohnt: Der erste brauchbare Stacktrace plus sauberer Kontext im Log verkürzt die Analyse massiv. Ohne das wird aus einem klaren IO-Problem ein „kommt manchmal vor“-Dauerthema.
Randfall: „Ich will die Message ergänzen“ – ohne Stacktrace zu zerbrechen
Der häufigste „Motivationsfehler“ für raise E; ist nicht Böswilligkeit, sondern Bequemlichkeit: Man möchte mehr Text. Embarcadero zeigt dafür ein sauberes Muster: Die Message der aktuellen Exception anpassen und danach mit raise; weiterwerfen.[Quelle] Damit bleibt es ein Re-Raise, nicht ein „neues Werfen“.
Aber auch hier lohnt ein kurzer Realitätscheck: Wenn ihr strukturiert loggt (Felder statt Text), ist es oft besser, die Original-Message unverändert zu lassen und Kontext separat zu erfassen. Das hält Signaturen stabil (Monitoring, Deduplizierung) und verhindert, dass Meldungen zu Datensilos werden.
Wenn Wrapping nötig ist: Ursache behalten statt Text zu kleben
Wrapping ist sinnvoll, wenn eine Schichtgrenze einen stabilen Fehlervertrag verlangt: etwa im REST-Server, bei Integrationen oder überall dort, wo technische Exceptions (SQL, Pfade, Hostnamen) nicht nach außen dürfen. Der Fehler bleibt intern technisch, extern wird er kontrolliert.
Der entscheidende Punkt: Wrapping darf nicht bedeuten, dass die Ursache verschwindet. Delphi unterstützt „nested exceptions“ (innere Exceptions), sodass die ursprüngliche Exception als Ursache erhalten bleiben kann, statt sie nur als Text in eine neue Message zu kopieren. Der Durdin-Artikel ordnet das als robustere Alternative ein und erklärt, warum das erneute Raisen eines referenzierten Exception-Objekts riskant ist.[Quelle]
Wann sich Wrapping wirklich lohnt (und wann nicht)
- Lohnt sich, wenn Clients automatisiert reagieren müssen (Fehlercode), wenn ihr Security-Details abschneiden müsst oder wenn Monitoring auf definierte Fehlertypen aggregieren soll.
- Lohnt sich oft nicht, wenn ihr in einer monolithischen Desktop-App ohne Schichtgrenzen nur „mehr Info“ wollt. Dann ist strukturiertes Logging plus
raise;meistens wartbarer als neue Exception-Hierarchien.
Spezialfall: raise ... at ... – Skalpell für wenige Situationen
Delphi kennt die Syntax raise <Exception> at <Address>, mit der sich die Exception Address gezielt setzen lässt. Das ist offiziell dokumentiert und kann beim Wrapping theoretisch helfen, den „sichtbaren Ursprung“ sinnvoll zu beeinflussen.[Quelle]
Im Alltag ist das aber selten das erste Mittel, aus drei Gründen:
- Wartbarkeit: Du erklärst damit nicht mehr nur „wirf weiter“, sondern du manipulierst Adressen. Das ist schwer zu reviewen und noch schwerer zu standardisieren.
- Toolchain-Abhängigkeit: Debug-/Release-Symbole, Optimierungen und Inlining beeinflussen, wie verlässlich „Adresse“ später interpretiert wird.
- Alternative ist klarer: Nested Exceptions plus gutes Logging liefern meist bessere, nachvollziehbare Diagnosen.
Typische Fehlerbilder – und die passende Gegenmaßnahme
1) „Alle Fehler kommen aus derselben Unit“
Wenn 80% eurer Stacktraces auf eine Handvoll Handler zeigen, ist das ein Anti-Muster-Signal. Prüfe zuerst auf raise E; und auf neu erzeugte Exceptions ohne Ursache. Das ist die schnellste Hebelstelle, bevor ihr Logging umbaut.
2) „Wir wrappen – und danach fehlt die technische Ursache“
Dann ist Wrapping vermutlich als Textverkettung umgesetzt. Ziel ist stattdessen: Wrapper für den Fehlervertrag, und die ursprüngliche Exception als innere Ursache. Der Logger muss beide Ebenen ausgeben können (Wrapper + Cause). Sonst bekommt der Betrieb zwar einen Fehlercode, aber keine Diagnose.
3) Access Violations treten nur im Fehlerpfad auf
Das ist genau der Bereich, in dem „seltene“ Regeln teuer werden: Fehlerpfade werden weniger getestet, treten aber unter Stress auf. raise E; ist hier ein bekannter Kandidat, weil die Lebensdauerannahme über das Exception-Objekt nicht belastbar ist.[Quelle] Wenn ihr so ein Muster im Code findet, ist das kein Stilthema, sondern Stabilitätsarbeit.
Debugging und Betrieb: Standards, die den Unterschied machen
Stacktrace-Qualität ist nur so gut wie eure Umgebung. Ein paar Standards entscheiden, ob ihr aus einem Crash-Bericht wirklich etwas ableiten könnt:
- Symbole/Map-Dateien organisiert halten: Release-Builds müssen nicht „debuggig“ sein, aber ihr braucht eine verlässliche Symbol-Archivierung, sonst bleiben Adressen im Nirwana.
- Strukturiertes Logging: Kontextdaten als Felder (Request-ID, Mandant, Operation, Objekt-ID). Das ist Support-Realität: Erst Log lesen, dann debuggen.
- Globaler Exception-Handler: Eine definierte Stelle entscheidet, was „nach außen“ passiert (UI-Dialog, HTTP-Fehler, Exitcode). Unten im Stack wird nicht „userfreundlich“ gemacht, sondern diagnostisch sauber.
- Keine Catch-all-Teppiche: Wer alles fängt und dann weiterläuft, produziert Folgefehler. Nach schweren Exceptions ist ein kontrollierter Abbruch oft das kleinere Risiko.
Abbruch- und Eskalationspunkte: Wann „weiter“ fachlich falsch ist
Sauberes Re-Raise hilft nur, wenn ihr auch sauber entscheidet. Es gibt Fehlerklassen, bei denen Fortsetzen mehr Schaden anrichtet als ein kontrollierter Abbruch:
- Datenintegrität: Unklare Transaktionslage, fehlgeschlagenes Commit/Flush – hier ist „weiter“ häufig der Weg zu inkonsistenten Daten. Abbrechen und sauber markieren ist die bessere Betriebsentscheidung.
- Ressourcenprobleme: Out-of-memory, Stack Overflow, Handle-Probleme. Retries machen es oft schlimmer; ein kontrollierter Neustart ist realistischer.
- Security-/Auth-Themen: Keine „Fallbacks“, die Berechtigungsfehler verwässern. Nach außen klar kommunizieren, intern vollständig protokollieren.
Diese Punkte gehören als Regeln in Runbooks und Architekturentscheidungen, nicht als spontane „try/except“-Kreativität.
Review-Checkliste: In 60 Sekunden die größten Risiken finden
- Steht im Re-Raise-Fall am Ende des
exceptwirklichraise;? - Findet ihr irgendwo
raise E;? Wenn ja: ändern oder schriftlich begründen lassen. - Wird beim Wrapping die ursprüngliche Exception als Ursache erhalten (nested), statt nur Text zu kopieren?
- Ist klar, wo „intern diagnostisch“ und wo „extern vertraglich“ entschieden wird (UI/HTTP/Exitcode)?
- Ist der Logkontext so, dass Betrieb und Support ohne Debugger starten können?
Der Kern, ohne Umwege
raise; ist in Delphi der saubere Re-Raise im except-Block: gleiche Exception, Kontext bleibt erhalten, Diagnose bleibt glaubwürdig.[Quelle] raise E; ist dagegen ein erneutes Raisen einer referenzierten Instanz, verfälscht häufig den sichtbaren Ursprung und kann wegen Lebensdauerannahmen instabil werden.[Quelle] Wer zusätzlich Domänenlogik und Fehlerverträge braucht, sollte bewusst wrappen (mit Ursache) und das Verhalten pro Schicht standardisieren. Dann sind Stacktraces nicht nur „schöner“, sondern im Betrieb tatsächlich nutzbar.
Wenn ihr das in einer gewachsenen Delphi-Codebasis vereinheitlichen wollt (inklusive Logging-Strategie und Review-Regeln), lässt sich das oft in kurzer Zeit sauber klären: Projekt oder Modernisierungsvorhaben mit Net-Base besprechen.
Quellen und weiterfuehrende Informationen
Die fachlichen Kernaussagen wurden anhand der folgenden externen Quellen redaktionell eingeordnet.
- Exceptions (Delphi) – RAD Studio (docwiki.embarcadero.com)
Embarcadero dokumentiert raise; als korrektes Re-Raise und warnt davor, stattdessen raise E zu verwenden; zudem wird das Muster gezeigt, eine Exception-Message zu ändern und dann mit raise; weiterzuwerfen. - How not to re-raise an exception in Delphi | Marc Durdin’s Blog (marc.durdin.net)
raise E (erneutes Raisen einer referenzierten Exception-Instanz) ist kein Re-Raise; die Lebensdauer des Exception-Objekts ist nicht sicher und kann zu instabilem Verhalten bis hin zu Access Violations führen. - Exceptions (Delphi) – RAD Studio (docwiki.embarcadero.com)
Delphi unterstützt raise … at …, um die Exception-Adresse gezielt zu setzen; relevant als Spezialtechnik beim Wrapping/Weiterreichen von Exceptions.
Für dieses Thema sind auch Delphi Exception Stacktrace und Delphi Raise Vs Raise E wichtig. Der Beitrag ordnet diese Aspekte verständlich ein und zeigt, worauf es im Alltag ankommt.
Projekt oder Modernisierungsvorhaben mit Net-Base besprechen.
Neste trinn
Når et tema blir et reelt prosjekt, bør arkitektur, eksisterende systemer og drift vurderes samlet allerede tidlig i prosessen.
Vi bistår ikke bare med enkeltspørsmål, men også når kodesnutter, legacy-temaer eller portalideer skal utvikles til et robust virksomhetsprosjekt.
- Eksisterende tilstand, målbildet og tekniske risikoer vurderes samlet.
- REST, datatilgang, portaler og utrulling blir ikke utsatt som etterfølgende oppgaver.
- Dere ser tidlig hvilken vei som er økonomisk og driftsmessig levedyktig.