Net-Base Rivista

21.11.2026

FireDAC: Query-Abbruch durch User-Cancel – AbortJob, UI-Thread-Signale und sauberes Aufräumen

Wenn ein Nutzer „Abbrechen“ klickt, entscheidet sich, ob deine Delphi-App stabil wirkt oder hängen bleibt. So setzt du den FireDAC Query-Abbruch durch User-Cancel sauber um – mit AbortJob, Thread-Grenzen, DataSource-Entkopplung und definiertem Cleanup.

21.11.2026

Dal tema della rivista alla pratica di progetto

Pagine di servizi e tecniche correlate all'articolo

Der Nutzer klickt auf „Suchen“. Das Grid wird leer, der Cursor wechselt, vielleicht läuft ein Spinner. Nach ein paar Sekunden kommt die Rückfrage: „Hängt das jetzt?“ Dann der Klick auf „Abbrechen“ – und genau in diesem Moment entscheidet sich, ob deine Anwendung professionell wirkt oder wie ein Zufallsprodukt: BDE-Ablosung mit nativer Anbindung Query-Abbruch durch User-Cancel.

Viele Teams reagieren in diesem Moment reflexhaft mit einem Flag („Cancelled := True“) oder mit Application.ProcessMessages. Beides wirkt kurzfristig beruhigend, löst aber das eigentliche Problem nicht: Der UI-Thread ist während Open/ExecSQL häufig in einem blockierenden Treiberaufruf gefangen. Er kann deinen Abbruchwunsch nicht verarbeiten, weil er nicht mehr „dran“ kommt.

BDE-Ablosung mit nativer Anbindung ist an der Stelle erfreulich klar: AbortJob muss aus einem anderen Thread aufgerufen werden als der Thread, der gerade Open, Execute oder Fetch ausführt.[Quelle] Das ist der entscheidende Moment dieser Szenarioanalyse: Abbrechen ist kein Button-Problem. Es ist ein Threading- und Lebenszyklus-Problem – inklusive sauberem Aufräumen, wenn der Abbruch tatsächlich passiert.

Der Knackpunkt: Warum „Cancel im selben Thread“ fast nie wirkt

Foto von markierten Logausdrucken und Timer als Symbol für Debugging von Cancel und Timeout.
Debugging im Alltag: Thread-IDs und Zustände nachvollziehbar machen.
Arbeitsplatzfoto mit Notizblock, auf dem ein Abbruch- und Cleanup-Ablauf einer Datenbankabfrage skizziert ist.
Typischer Randfall: Grid gebunden, Query läuft asynchron, Cancel wird angefordert.
Grafische Darstellung eines Abbruchflusses zwischen UI-Thread, Worker-Thread und Datenbankzugriff ohne Text.
Abbruchfluss als klare Kette: UI-Signal, Worker, DB-Treiber, Cleanup.

Wenn eine FireDAC-Query im UI-Thread ausgeführt wird, ist der Thread währenddessen mit SQL-Ausführung, Netzwerk-I/O oder Resultset-Fetching beschäftigt. In der Zeit:

  • werden UI-Events nicht (oder erst später) verarbeitet,
  • kann dein Cancel-Flag nicht geprüft werden,
  • kann ein Abbruchaufruf im selben Thread gar nicht erst ausgeführt werden.

Die weniger hilfreiche Reaktion ist dann, das UI „am Leben zu halten“: ProcessMessages, zusätzliche Timer, noch ein Button, noch ein Flag. Das führt zwar zu mehr Ereignissen, aber nicht zu weniger Blockade. Nebenwirkung: Reentrancy. Ein zweiter Klick startet eine zweite Suche, während die erste noch läuft. Oder der Nutzer schließt das Formular, während das Dataset mitten im State-Wechsel steckt.

Die bessere Reaktion: Die Ausführung muss aus dem UI-Thread heraus, und Cancel muss den laufenden Job wirklich erreichen – technisch, nicht nur logisch.

FireDAC Query-Abbruch durch User-Cancel: Zwei robuste Wege

Für praxisnahe Delphi-Anwendungen haben sich zwei Ansätze bewährt. Beide sind „FireDAC-konform“, unterscheiden sich aber in Kontrolle, UI-Integration und Aufwand.

Weg A: CmdExecMode = amCancelDialog (schnell, standardisiert)

Wenn du einen akzeptablen Standarddialog nutzen kannst, ist FireDACs eingebauter Cancel-Flow der kürzeste Weg: Setze ResourceOptions.CmdExecMode := amCancelDialog und platziere eine TFDGUIxAsyncExecuteDialog-Komponente. FireDAC zeigt dann bei längeren Operationen einen Dialog, der einen Abbruch ermöglicht.[Quelle]

Wann das gut passt: interne Admin-Tools, klassische Desktop-Masken, Situationen, in denen „modal + Cancel“ akzeptiert ist und der UI-Style nicht strikt eingehalten werden muss.

Grenzen: Du gibst UI-Kontrolle ab (Dialog-UX), und du baust häufig trotzdem eigenen Status, Logging und Folgeaktionen (Rollback, UI zurücksetzen). Spätestens wenn der Cancel-Button in deine Oberfläche soll oder du mehrere parallele Jobs koordinierst, wird Weg B interessanter.

Weg B: Asynchron ausführen (amAsync/Worker) und Cancel selbst steuern

FireDAC dokumentiert für die asynchrone Ausführung (amAsync) auch den programmatischen Abbruch: Du kannst die Ausführung abbrechen, indem du AbortJob am Dataset/Command aus einem anderen Thread aufrufst; die Connection bietet ebenfalls AbortJob, um alle Operationen dieser Verbindung zu stoppen.[Quelle]

Wichtiger Nebeneffekt: Du kannst Cancel, Busy-State, Statuszeile und UX so gestalten, wie es zu deiner Business-Software passt. Du kontrollierst außerdem besser, welche Ressourcen wann freigegeben werden und wie du Folgeoperationen zulässt (z. B. „direkt neue Suche starten“ nach Cancel).

Welche Ebene wird abgebrochen: Dataset, Command oder Connection?

Im Alltag wird oft „FDCommand.Abort“ gesagt. In FireDAC heißt die dokumentierte Abbruch-API AbortJob. Du kannst sie auf unterschiedlichen Ebenen nutzen, je nachdem, wie groß der „Radius“ des Abbruchs sein darf.

Abbruchziel Was es abbricht Guter Einsatzfall Was du dabei riskierst
Dataset.AbortJob (z. B. TFDQuery) Aktuellen Job genau dieser Query Interaktive Suche/Report pro Maske Wenn UI noch gebunden ist: Folge-Events in unerwarteten Dataset-States
TFDCustomCommand.AbortJob Open/Execute/Fetch; danach definierter Command-State Gezielter Abbruch, wenn du Commands bewusst nutzt „Best effort“: Abbruchzeit hängt von DB/Driver ab; danach State sauber behandeln
Connection.AbortJob Alle Operationen auf dieser Connection Notbremse, wenn du nicht mehr weißt, was gerade blockiert Trifft auch unbeteiligte Jobs; Ownership/Threading muss sauber sein

Für Debugging und Zustandslogik ist wichtig, was die API-Doku konkret sagt: AbortJob kann Open, Execute oder Fetch abbrechen; danach fällt der Command bei Open/Execute auf csPrepared zurück, bei Fetch auf csActive.[Quelle] Das ist nicht nur Theorie: Du kannst daraus ableiten, ob du „nur schließen“ oder „neu vorbereiten“ musst.

Threading-Regeln: Ohne Ownership-Modell wird Cancel zum Glücksspiel

Der Abbruchmechanismus steht und fällt mit Threading-Disziplin. FireDAC ist multithreading-fähig, aber nicht im Sinne von „jeder macht alles überall“. Die Leitplanke lautet praktisch: Eine Connection und alle daran hängenden Objekte (Queries, Transactions, Commands) dürfen zu einem Zeitpunkt nur von einem Thread benutzt werden. Und: FDManager.Active sollte gesetzt sein, bevor Worker-Threads starten.[Quelle]

Konsequenz für Architektur und Betrieb: Cancel ist nicht „UI ruft Abort auf irgendeinem Objekt“, sondern ein kontrollierter Übergang zwischen Zuständen. Das betrifft auch Admins/Tech-Leads: Wenn eine Anwendung sporadisch hängt oder AVs wirft, liegt die Ursache oft in verdeckter Cross-Thread-Nutzung derselben Connection.

Ein pragmatisches Ownership-Modell für interaktive Queries

  • UI-Thread: besitzt UI-Status (Busy, Buttons, Progress), aber keine aktiv arbeitende Connection.
  • Worker-Thread: besitzt Connection + Query/Command für diesen Job; führt aus und meldet Completion zurück.
  • Cancel: ist ein Signal an den Worker (oder ein AbortJob-Aufruf aus einem separaten Thread), aber niemals „UI und DB gleichzeitig“.

Das Modell klingt streng, macht aber später Migration und Wartung deutlich leichter: Du kannst Jobs kapseln (Suche, Report, Export) und jeden Job sauber stoppen, ohne Nebenwirkungen in anderen Bereichen.

Fetch ist oft der wahre Bremsklotz – und der häufigste Cancel-Randfall

In Logs sieht man gern „Query läuft noch“. In der Nutzerwahrnehmung hängt es aber oft nicht an der Server-Ausführung, sondern am Fetch großer Datenmengen: Das Nachladen blockiert, das Grid will rendern, DataLinks feuern, und Cancel fühlt sich wirkungslos an.

FireDAC benennt hier eine harte Einschränkung: „Fetching with GUI cannot be performed in amAsync mode“. Der dokumentierte Workaround ist, FetchOptions.Mode := fmAll zu setzen, damit Open und Fetch als ein Background-Task laufen.[Quelle]

Praktische Entscheidung: Willst du Teilergebnisse (frühes Anzeigen, späteres Nachladen) oder „alles oder nichts“? Für Trefferlisten ist „alles oder nichts“ oft die stabilere Variante, weil du Cancel als klaren Zustand abbilden kannst: Liste bleibt leer, Status sagt „abgebrochen“, Benutzer kann neu starten.

Konstruiertes Beispiel: Cancel während Fetch, danach AV

Genau dieses Entkoppeln beschreibt FireDAC in der Doku zur asynchronen Ausführung: Bei GUI-Bindung via TDataSource sollst du vor Open trennen und nach AfterOpen wieder anbinden.[Quelle] Das ist kein kosmetischer Trick, sondern verhindert, dass GUI-Komponenten Zwischenzustände „sehen“ und darauf reagieren.

Sauberes Aufräumen: Der Teil, der im Alltag Tickets spart

Cancel ist nicht der Klick. Cancel ist das, was danach übrig bleibt. Die meisten Probleme im Betrieb entstehen, weil nach dem Abbruch ein halber Zustand stehen bleibt: Buttons disabled, Cursor „busy“, Query noch active, Transaktion offen, Connection in undefiniertem Zustand, DataSource zeigt auf ein Dataset, das gerade abgebrochen wurde.

Ein Cleanup-Pfad für Erfolg, Fehler, Cancel und Timeout

Wenn du nur eine Sache standardisierst, dann das: ein zentraler Cleanup-Pfad, der in allen Endzuständen läuft. Eine kompakte, aber praxistaugliche Schrittfolge:

  1. UI-State zurücksetzen: Busy aus, Buttons/Shortcuts wieder erlauben, Progress stoppen.
  2. DataSource konsistent setzen: Wenn vor Start getrennt wurde, nur nach erfolgreichem Ende wieder verbinden; bei Cancel/Fehler bewusst leer lassen.
  3. Dataset/Command stabilisieren: Entscheide pro Use Case, ob du Close erzwingst oder prepared/active weiterverwendest. Nicht „mal so, mal so“.
  4. Transaktion behandeln: Bei interaktiven Suchen ist Rollback nach Cancel meist die sichere Default-Logik, wenn du überhaupt explizite Transaktionen nutzt.
  5. Logging klassifizieren: Cancel/Timeout nicht als Fehler-Explosion zählen lassen; aber trotzdem nachvollziehbar protokollieren (z. B. „abgebrochen“, Dauer, Kontext).
  6. Ressourcen freigeben: Temporäre Dateien, Streams, große Buffer, UI-Objekte für Fortschritt, Handles.

Ein wichtiger Nebeneffekt für Admins und Support: Wenn Cancel sauber als eigener Endzustand behandelt wird, werden Monitoring und Fehlerstatistik aussagekräftiger. „Abgebrochen“ ist kein Incident – es ist Nutzerinteraktion.

Timeout ist ein zweiter Abbruchpfad – und sollte sich ähnlich verhalten

Neben User-Cancel brauchst du häufig eine harte obere Grenze: ResourceOptions.CmdExecTimeout. FireDAC beschreibt, dass bei Timeout abgebrochen und eine Exception geworfen wird; als Erkennung wird exemplarisch EFDDBEngineException mit Kind = ekCmdAborted gezeigt (im Kontext der asynchronen Ausführung).[Quelle]

Praktische Konsequenz: Du kannst Cancel und Timeout im Cleanup gleich behandeln, aber in der UI differenziert kommunizieren („vom Nutzer abgebrochen“ vs. „Zeitlimit überschritten“). Das reduziert Rückfragen und macht Betriebsmeldungen klarer.

Debugging-Check: Wenn AbortJob „nicht funktioniert“

1) Thread-IDs loggen, sonst rätst du

Der häufigste Fehler ist trivial: AbortJob wird doch im gleichen Thread aufgerufen, in dem gerade blockiert wird. Die Doku ist eindeutig: „from the other thread“.[Quelle] Ohne Thread-ID im Log siehst du das nicht. Logge mindestens: Start, Cancel-Request, AbortJob-Call, Exception-Catch, Cleanup-Done – jeweils mit Thread-ID.

2) Abbruch ist „best effort“ – DB/Driver entscheidet über Reaktionszeit

FireDAC weist darauf hin, dass nicht alle DBMS-APIs ein echtes Execution-Cancel unterstützen; dann wartet AbortJob unter Umständen, bis das DBMS fertig ist.[Quelle] Das ist keine Ausrede, sondern eine Planungsgrundlage: UX und Betrieb brauchen einen Zustand „Cancel angefordert“, und du brauchst Timeouts als zusätzliche Absicherung.

3) GUI-Bindings sind oft die versteckte Ursache für Folgefehler

Wenn nach Cancel sporadisch AVs kommen, schau zuerst auf Bindings und Zustandswechsel: Ist ein Grid an ein Dataset gebunden, das im Hintergrund abgebrochen wurde? Hast du DataSource vor Async-Open getrennt und erst nach AfterOpen wieder verbunden, wie dokumentiert?[Quelle]

4) Zustand nach AbortJob bewusst auswerten

Die API-Doku beschreibt den Command-State nach Abbruch (csPrepared/csActive je nach Phase).[Quelle] Nutze das als Diagnose: Wenn du nach Cancel in einem unerwarteten Zustand landest, ist das oft ein Hinweis auf vermischte Verantwortlichkeiten (z. B. UI greift doch noch auf Query/Connection zu).

Wann lohnt sich der Aufwand – und wo sind die Grenzen?

Sauberer Query-Abbruch ist kein Selbstzweck. Er lohnt sich zuverlässig, wenn mindestens einer dieser Punkte zutrifft:

  • Abfragen dauern gelegentlich länger als wenige Sekunden (Reports, große Filter, Remote-DB).
  • Du hast realistische Störbedingungen (Locks durch Batch-Jobs, Netzwerk-Latenz, parallele Exporte).
  • Nutzer arbeiten „interaktiv“ (Filtern, Drilldown, wiederholte Suche) und erwarten Reaktionsfähigkeit.
  • Support-Aufwand soll sinken: weniger „Programm hängt“, bessere Logs, weniger harte Prozess-Abschüsse.

Grenzen sollten trotzdem klar sein:

  • Cancel ist nicht immer sofort. DBMS und Treiber bestimmen, wie gut ein Interrupt umgesetzt wird.
  • Cancel erhöht die Zustandskomplexität. Du brauchst eine kleine Zustandsmaschine (idle/running/cancel requested/completed/failed), sonst entstehen schwer erklärbare Effekte.
  • Cancel und Transaktionen müssen zusammen gedacht werden. Ohne klare Rollback-Regel riskierst du Nebenwirkungen, die erst später sichtbar werden.

Der bessere Reflex im Team: Cancel als Architekturtest, nicht als UI-Feature

Wenn du Cancel einbaust, teste nicht nur „klick und weg“. Teste die Situationen, die später Tickets erzeugen:

  • Cancel während Fetch großer Ergebnismengen
  • Cancel bei Lock-Wartezeit (anderer Prozess blockiert)
  • Cancel und sofort neue Suche starten
  • Cancel und danach Form schließen
  • Timeout und Cancel zeitlich nahe beieinander (wer setzt welchen Zustand?)

Wenn diese Fälle sauber sind, wirkt die Anwendung im Alltag stabil – und du bekommst weniger „Hänger“-Meldungen, die am Ende doch nur ein fehlender Abbruchpfad waren.

Der Schlusspunkt: Nach „Abbrechen“ muss ein definierter Zustand stehen

Ein guter User-Cancel hinterlässt keine Unordnung. Die Oberfläche ist wieder bedienbar, Datenbindungen sind konsistent, Connection und Query sind in einem erwartbaren Zustand, Logs unterscheiden Abbruch von Fehler. FireDAC liefert die technischen Haken dafür – AbortJob, Async-Execution, Cancel-Dialog – aber die Stabilität entsteht erst durch Ownership, entkoppelte GUI-Bindung und einen einzigen, verlässlichen Cleanup-Pfad.

Quellen und weiterfuehrende Informationen

Die fachlichen Kernaussagen wurden anhand der folgenden externen Quellen redaktionell eingeordnet.

  1. FireDAC.Comp.Client.TFDCustomCommand.AbortJob – RAD Studio API Documentation (docwiki.embarcadero.com)
    AbortJob muss aus einem anderen Thread aufgerufen werden als der Thread, der Open/Execute/Fetch ausführt; Abbruch ist best effort und der Command-State nach Abbruch ist definiert.
  2. Asynchronous Execution (FireDAC) – RAD Studio (docwiki.embarcadero.com)
    FireDAC bietet asynchrone Ausführung (amAsync), Hinweise zur GUI-Bindung (DataSource trennen/wieder verbinden) sowie AbortJob/Timeout-Mechanismen im Async-Kontext.
  3. GUI Questions (FireDAC) – RAD Studio (docwiki.embarcadero.com)
    Für User-Cancel kann FireDAC über CmdExecMode = amCancelDialog mit TFDGUIxAsyncExecuteDialog einen Abbrechen-Dialog bereitstellen.
  4. Multithreading (FireDAC) – RAD Studio (docwiki.embarcadero.com)
    FireDAC-Multithreading-Regeln: Connection und abhängige Objekte dürfen nicht gleichzeitig aus mehreren Threads verwendet werden; FDManager vor Worker-Threads aktivieren.

Für dieses Thema sind auch Fdcommand Abort und FireDAC Amasync wichtig. Der Beitrag ordnet diese Aspekte verständlich ein und zeigt, worauf es im Alltag ankommt.

Projekt oder Modernisierungsvorhaben mit Net-Base besprechen.

Passo successivo

Quando un tema diventa un progetto reale, architettura, sistemi esistenti e gestione operativa dovrebbero essere considerati insieme fin dalle fasi iniziali.

Non forniamo solo supporto per questioni isolate, ma anche quando da frammenti di codice sorgente, tematiche legacy o idee di portale deve nascere un progetto aziendale solido.

  • Stato attuale, stato obiettivo e rischi tecnici vengono valutati insieme.
  • REST, l'accesso ai dati, i portali e il rollout non vengono rinviati a fasi successive.
  • Vede in anticipo quale percorso è economicamente e operativamente sostenibile.

Condividi il post

Condividi direttamente questo articolo

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

E-mail

Instagram si apre in una nuova scheda. Il link e il breve testo vengono copiati prima negli appunti.

Scrivi un commento

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