Net-Base Magazine

11.11.2026

Delphi: Exception-Stacktrace sauber durchreichen – raise; vs. raise E; und wie du den Ursprung behältst

Wenn der Stacktrace plötzlich im except-Block endet, ist oft raise E; im Spiel. Dieser Praxisleitfaden zeigt, warum raise; der saubere Re-Raise ist, wie du Kontext anreicherst, Exceptions sauber wrappst und typische Debugging-Fallen vermeidest.

11.11.2026

Van magazinethema naar projectpraktijk

Relevante dienst- en technische pagina's bij het artikel

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?

Foto eines Architekturdiagramms mit zwei Exception-Pfaden für Wrapper und Ursache
Wrappen ja – aber den Originalfehler als Ursache behalten.
Abstrakte Grafik mit zwei Callstack-Verläufen: einmal mit erhaltenem Ursprung, einmal mit verschobenem Ursprung
Wenn der Ursprung im Catch-Block landet, ist die Diagnose oft unnötig teuer.

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; oder raise(E) innerhalb von except
  • 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.

  1. Catch nur dort, wo du wirklich handeln kannst: Rollback, Ressourcen schließen, Retry-Entscheidung. Nicht „zur Sicherheit“ überall.
  2. Kontext erfassen, den der Callstack nicht liefert: Operation/Use-Case, betroffene ID, Datei/Endpoint, Mandant, Request-ID (Korrelation).
  3. Cleanup trennen: Ressourcen gehören in finally, Fehlerpfad in except. Das reduziert Nebenwirkungen.
  4. Re-Raise korrekt: im except am Ende raise;.
  5. 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

  1. Steht im Re-Raise-Fall am Ende des except wirklich raise;?
  2. Findet ihr irgendwo raise E;? Wenn ja: ändern oder schriftlich begründen lassen.
  3. Wird beim Wrapping die ursprüngliche Exception als Ursache erhalten (nested), statt nur Text zu kopieren?
  4. Ist klar, wo „intern diagnostisch“ und wo „extern vertraglich“ entschieden wird (UI/HTTP/Exitcode)?
  5. 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.

  1. 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.
  2. 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.
  3. 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.

volgende stap

Wanneer het onderwerp een concreet project wordt, moeten architectuur, bestaande omgeving en exploitatie vroegtijdig samen worden bekeken.

We ondersteunen niet alleen bij individuele vragen, maar ook wanneer uit broncodefragmenten, legacy-onderwerpen of portalideeën een robuust bedrijfsproject moet ontstaan.

  • Huidige situatie, doelbeeld en technische risico's worden gezamenlijk beoordeeld.
  • REST, toegang tot gegevens, portalen en rollout worden niet naar latere fasen verschoven.
  • U ziet vroeg welke weg economisch en operationeel levensvatbaar is.

Bericht delen

Dit bericht direct delen

LinkedIn, X, Facebook, WhatsApp und E-Mail sind sofort verfügbar. für Instagram bereiten wir Link und Kurztext direkt vor.

E-mail

Instagram opent in een nieuw tabblad. Link en korte tekst worden van tevoren naar het klembord gekopieerd.

Reactie schrijven

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert