Net-Base Lehti

14.11.2026

Delphi: Named Pipes Client/Server in 50 Zeilen – Timeout, ReadFile-Hänger und sauberes Disconnect-Handling

ReadFile hängt, Stop bleibt stehen, Disconnect wirkt zufällig: So machst du Delphi Named Pipes mit Timeout-Design, Overlapped-I/O oder Cancel-Strategie betriebsfest – inklusive Connect-Race und Debugging-Checks.

14.11.2026

Lehden aiheesta projektikäytäntöön

Artikkeliin liittyvät palvelu- ja tekniikkasivut

Leserfrage: „Ich habe einen Delphi Named Pipes Client/Server in wenigen Zeilen. Im Test läuft’s. Im Betrieb hängt mir ReadFile weg, der Windows- und Linux-Services stoppt nicht sauber und ‚Disconnect‘ fühlt sich zufällig an. Was ist der richtige Weg für Timeout, ReadFile-Hänger und sauberes Disconnect-Handling?“

Vorläufige Antwort: Ein echter Read-Timeout ist bei klassischen Win32-Named-Pipes kein Parameter, den man „mal eben“ setzt. Wenn du synchron (ohne Overlapped-I/O) liest, ist Blockieren das Standardverhalten. Stabil wird das erst, wenn du dein Timeout- und Stop-Verhalten bewusst designst: entweder Overlapped-I/O mit eigenem Warten (und Timeout) oder eine Cancel-Strategie für synchrone Reads – plus ein kleines Protokoll (Framing), das Nachrichten eindeutig begrenzt.

Delphi Named Pipes Timeout: Warum die „50 Zeilen“ im Alltag kippen

Debugger-Szene mit unscharfer Thread-Ansicht und Notizen zu einem blockierenden ReadFile in einer Named-Pipe
Typischer Hänger: Stop wartet, weil ein Thread im blockierenden Read festhängt (ohne Overlapped).
Schematische Darstellung einer Named-Pipe mit Overlapped-Read, Event-Signal und Timeout-Wartepfad
Overlapped-I/O als kontrollierbarer Wait-Pfad: Event-Signal statt blockierender Read-Calls.

Der typische Ablauf ist schnell geschrieben: Server erstellt eine Pipe, wartet auf Connect, liest in einer Schleife, antwortet. So ein Minimalaufbau wirkt in der IDE robust, weil der Client „artig“ sendet und sauber schließt.

Im Alltag kommen drei Dinge dazu, die Minimalcode nicht „mitliefert“:

  • Stille Verbindungen: Der Client ist verbunden, sendet aber minutenlang nichts (UI blockiert, Task läuft, Prozess hängt). Dein Server ist dann trotzdem „busy“.
  • Stop/Shutdown unter Last: Ein Service soll im Wartungsfenster stoppen, während Worker-Threads in ReadFile warten. Ohne Abbruchstrategie hängt das Stop-Signal in der Warteschleife.
  • Disconnect ist keine Callback-Info: Eine Named Pipe verhält sich wie Datei-/Stream-I/O. Dass die Gegenseite weg ist, merkst du erst bei der nächsten Operation (Read/Write) oder über definierte Fehlercodes.

Der Kern ist nicht Delphi, sondern Win32-I/O: ReadFile, WriteFile, ConnectNamedPipe laufen entweder synchron (blockierend) oder asynchron im Overlapped-Modus. „Asynchron“ passiert nur, wenn Handle und Aufruf dazu passen. Microsoft beschreibt diese Unterscheidung explizit: Ohne Overlapped ist es blocking I/O – und dann ist ein „Hänger“ oft schlicht „wartet korrekt“. [Quelle]

Die Klarstellung, die viele Diskussionen abkürzt: ReadFile hat keinen Timeout-Parameter

Wer von Sockets kommt, sucht gerne nach „ReadTimeout“ am API. Bei Named Pipes ist das der falsche Hebel: ReadFile hat bei klassischem Win32 keinen Timeout-Parameter. Wenn du synchron liest, wartet der Thread im Kernel. Wenn du einen harten Timeout willst, musst du den Call asynchron gestalten (Overlapped) und selbst mit Timeout warten, oder den synchron blockierten Thread gezielt abbrechen (Cancel). [Quelle]

Praktische Folge für Architektur und Betrieb: Ein Timer im Delphi-Code hilft nicht, wenn der Thread gerade nicht mehr in Delphi läuft, sondern im blockierenden Systemcall steckt. Ein Timeout ist also kein „Feature“, sondern ein Designentscheid.

Timeouts richtig sortieren: Connect-Timeout ist nicht Read-Timeout

Viele Fehleranalysen vermischen zwei komplett unterschiedliche Wartephasen:

  • Warten, bis eine Pipe-Instanz verfügbar ist (Client-Connect-Phase): Wenn alle Server-Instanzen belegt sind, kann der Client per WaitNamedPipe mit Timeout auf eine freie Instanz warten. Die Semantik dieses Wartens ist im FSCTL-/Protokollkontext definiert. [Quelle]
  • Warten auf Nutzdaten (Read-Phase): Das ist dein ReadFile. Hier hilft WaitNamedPipe nicht, weil du ja längst verbunden bist.

Für Debugging und Betrieb ist das Gold wert: „Client findet keine freie Instanz“ ist ein Kapazitäts-/Instanzen-Thema. „Client ist verbunden, aber Read blockiert“ ist ein Protokoll- oder Abbruchthema. Beides braucht andere Maßnahmen, anderes Logging, andere Tests.

Disconnect-Handling: Broken Pipe und „0 Bytes“ gehören zum Normalbetrieb

Ein sauberer Disconnect ist keine Kür, sondern der häufigste „Fehler“ im Log – und sollte auch so behandelt werden: als reguläres Ende einer Session.

  • Beim Lesen siehst du typischerweise entweder ReadFile mit false und GetLastError=ERROR_BROKEN_PIPE oder einen erfolgreichen Return mit BytesRead=0 (EOF-ähnlich, abhängig von Situation und Pipe-Typ).
  • Beim Schreiben kann WriteFile ebenfalls mit ERROR_BROKEN_PIPE enden, wenn der Peer weg ist. Ein „Retry um jeden Preis“ verschlimmert hier meist nur das Stop-Verhalten.

Wichtig ist die Trennung in Kategorien, nicht die kosmetische Behandlung: Ein „Peer disconnected“ ist etwas anderes als „Protokoll ungültig“ und etwas anderes als „Timeout“. Wenn du alles unter „I/O error“ zusammenkippst, ist dein Support später blind.

ConnectNamedPipe und das Race, das unter Last plötzlich auftaucht

Ein Klassiker, der sich als „sporadisch“ tarnt: Der Server macht CreateNamedPipe und danach ConnectNamedPipe. Ein Client kann aber genau zwischen diesen Aufrufen schon verbinden. Microsoft dokumentiert das ausdrücklich – und beschreibt, dass ConnectNamedPipe dann mit einem Status zurückkommen kann, der nicht als „echter Fehler“ zu werten ist: ERROR_PIPE_CONNECTED bedeutet in diesem Kontext „Client ist bereits verbunden“, du musst den Zustand also als „connected“ behandeln. [Quelle]

Wer diesen Pfad nicht sauber abfängt, bekommt Connect-Fehler, die durch Retries „weggehen“ – bis im Betrieb plötzlich Lastspitzen oder parallel startende Clients das Thema sichtbar machen.

Welche Wege realistisch sind – und welcher Preis jeweils dranhängt

Ansatz Was du damit erreichst Was du nicht bekommst Typischer Stolperstein
Synchrones ReadFile im Worker-Thread Sehr wenig Code, gut verständlich, oft ausreichend für „nur lokal, nur wenige Clients“ Kein echter Read-Timeout; Stop/Shutdown bleibt ohne Zusatzmechanik riskant Service stoppt nicht, wenn Client verbunden aber still ist
Overlapped-I/O + Wait (Timeout) Kontrollierbares Warten, definierte Timeouts, Stop wird testbar „Einfach mal eben“ ist es nicht; du musst Events/Overlapped sauber verwalten Handle im falschen Modus oder falsche Overlapped-Verwendung führt zu schwerem Chaos
Synchron + gezielter Abbruch (Cancel) Du kannst blockierende synchrone I/O für Stop/Shutdown beenden Kein „dauerhafter Timeout“ ohne zusätzliche Logik; Cancel ist eher ein Not-Aus Cancel aus dem falschen Thread wirkt nicht oder wirkt nicht wie erwartet
Framing (Längenprefix) + Read-Loop Protokoll wird deterministisch, halbe Reads sind beherrschbar, Debugging wird klarer Allein löst es keinen „stillen Client“; du brauchst trotzdem eine Abbruchstrategie Ohne Maximalgröße/Validierung kannst du dir Memory- oder DoS-Probleme einhandeln

Der saubere Kern: Framing plus Abbruchstrategie (nicht „mehr Tricks“)

Abstrakte Darstellung von Nachrichten-Framing mit Längenprefix und Payload in einem Stream
Framing-Prinzip: Längenprefix und Payload als robuste Nachrichtenstruktur für Pipes.

Wenn du Named Pipes betriebsfest machen willst, lohnt es, die Arbeit an den richtigen Stellen zu konzentrieren. Zwei Bausteine zahlen fast immer direkt zurück:

  1. Framing: Jede Nachricht bekommt eine klare Begrenzung (z. B. 4-Byte-Längenprefix + Payload). Damit ist „Nachricht vollständig“ nicht mehr Bauchgefühl. Du kannst Maximalgrößen definieren und Protokollfehler klar loggen.
  2. Abbruchstrategie: Du definierst, wie ein Read endet, wenn keine Daten kommen: Overlapped mit Timeout-Wait oder gezieltes Cancel für synchrone Reads (typisch im Stop-Pfad).

Das klingt unspektakulär, ist aber genau der Unterschied zwischen „läuft im Test“ und „wartbar im Betrieb“. Ohne Framing jagst du Phantomprobleme („Warum kam nur ein Teil?“). Ohne Abbruchstrategie jagst du Zombie-Threads.

Konstruierte Alltagsszene: Der Stop hängt, obwohl „eigentlich niemand mehr verbunden ist“

Overlapped-I/O: Der Gewinn ist Betriebskontrolle, nicht „Asynchronität als Selbstzweck“

Overlapped-I/O heißt: Du startest einen Read, bekommst bei ausstehendem Ergebnis typischerweise ERROR_IO_PENDING und wartest dann selbst auf ein Event (oder mehrere), mit einem Timeout, das du definierst. Damit verschiebst du die Kontrolle über „wie lange darf gewartet werden“ zurück in deinen Prozess.

Microsoft zeigt Overlapped-I/O für Named-Pipe-Server als Referenzmuster. Der praktische Wert liegt im Stop/Shutdown und in messbaren Wartezeiten: Du kannst sauber loggen „Timeout nach 5s“, du kannst Sessions gezielt beenden, und du kannst vermeiden, dass ein Worker-Thread unkündbar im Kernel blockiert. [Quelle]

Für technische Leads ist das die richtige Brille: Overlapped ist ein Werkzeug für deterministisches Betriebsverhalten. Performance ist höchstens ein Nebeneffekt.

Wenn du synchron bleiben willst: CancelSynchronousIo als gezielter Stop-Hebel

Manchmal ist synchrones I/O eine bewusste Entscheidung: pro Client ein Thread, klarer Call-Stack, Debugging im klassischen Stil. Dann brauchst du dennoch einen Ausweg für Stop/Shutdown, sonst ist der Dienst bei „stillem Client“ nicht beherrschbar.

Microsoft nennt CancelSynchronousIo als Möglichkeit, ausstehende synchrone I/O abzubrechen. Das ist direkt relevant für das „ReadFile hängt“-Problem – allerdings nur, wenn du die Randbedingungen beachtest (insbesondere Thread-Bezug). [Quelle]

Praktische Designkonsequenz: Dokumentiere Thread-Ownership sauber. Wer darf canceln? Wer hält welches Handle? Wie wird der Stop-Pfad synchronisiert, damit du nicht „nebenbei“ ein anderes I/O triffst? Ohne diese Klarheit tauscht du einen Hänger gegen unzuverlässiges Verhalten.

Schrittfolge: Robustheit in 7 Schritten nachrüsten (ohne den ganzen Stack umzubauen)

  1. Zustandslogging einführen: Nicht nur Errors, sondern Zustände wie „connecting“, „connected“, „read header“, „read payload“, „write“, „disconnecting“. Das ist später deine Zeitleiste.
  2. Framing definieren: Längenprefix + Payload. Lege Maximalgrößen fest und logge Überschreitungen als Protokollfehler, nicht als „I/O kaputt“.
  3. Connect-Race korrekt behandeln: ERROR_PIPE_CONNECTED ist im dokumentierten Race-Fall ein „connected“-Signal, kein Grund für Reconnect-Orgien.
  4. Disconnect sauber kategorisieren: ERROR_BROKEN_PIPE und „0 Bytes gelesen“ sind normale Session-Enden. Logge sie als Info/Session-Ende, nicht als Alarm.
  5. Timeout-Definitionen schriftlich machen: Transport-Timeout (Wait), Protokoll-Timeout (keine Fortschritte). Beides getrennt.
  6. Stop/Shutdown testbar machen: Baue den Stop-Pfad so, dass blockierende Reads enden (Overlapped-Cancel oder CancelSynchronousIo-Strategie). Test: Client verbunden, sendet nie.
  7. Testfälle erzwingen: Parallel-Connect, Client killen, große Payloads, langsames Senden, wiederholtes Connect/Disconnect. Ohne diese Tests bleibt „stabil“ eine Vermutung.

Debugging: Drei Checks, die bei ReadFile-Hängern fast immer weiterhelfen

1) Den Hänger bewusst provozieren

Baue einen Testclient, der verbindet und dann nichts sendet. Kein „random“, keine Lastgeneratoren. Nur Stille. Wenn dein Service dann beim Stop hängt, hast du den Kernfall reproduziert.

2) Wo wartet der Thread wirklich?

Bei synchronem I/O siehst du im Dump typischerweise einen Thread in einem wartenden Systemcall. Bei Overlapped siehst du den Wait (z. B. auf ein Event). Das klingt trivial, spart aber Stunden Diskussion: Ein Timer „im Delphi-Code“ kann einen blockierten Systemcall nicht aufwecken, solange du keine Abbruchstrategie hast.

3) Fehlercodes nicht glätten

Ein häufiger Fehler ist „wenn ReadFile fehlschlägt, reconnect“. Damit wirfst du weg, ob es ein regulärer Disconnect (ERROR_BROKEN_PIPE), ein Connect-Race, ein Security-Problem (ACL/Access denied) oder eine Protokollverletzung war. Lass die Codes im Log sichtbar und mappe sie erst in der Auswertung zu Kategorien.

Betrieb und Sicherheit: Named Pipes sind nicht automatisch „lokal und sicher“

Named Pipes passen gut in Windows-Umgebungen, weil du über Security Descriptors/ACLs sehr präzise steuern kannst, wer verbinden darf. Genau das ist in Unternehmensumgebungen oft attraktiver als „irgendein TCP-Port“. Gleichzeitig entstehen typische Betriebsfallen:

  • Session-Isolation (Service vs. User): Dienste laufen in Session 0, Clients in User-Sessions. Rechte, Pipe-Name und Zugriff müssen dazu passen, sonst sind Fehler „sporadisch“ (je nachdem, wer gestartet hat).
  • Domänenkonten und Gruppen: Wenn du auf AD-Gruppen setzt, brauchst du klare Rollout-Regeln. Sonst geht es im Test, aber nicht auf der Zielmaschine.
  • Least Privilege: Nicht „Everyone Full Control“, nur weil es schneller ist. Definiere minimale Rechte (Connect/Read/Write) und halte das im Hardening-Konzept fest.

Für Admins ist die Betriebsfrage simpel: Ist diese Pipe ein Integrationspunkt einer digitalen Unternehmenslösung? Dann gehört sie in die Betriebsdokumentation: Accounts, Rechte, Rotation/Deployment, Logging, und ein reproduzierbarer Stop-Test.

Wann Named Pipes wirklich passen – und wann du umschwenken solltest

Named Pipes lohnen sich, wenn du IPC auf einem Windows-Host sauber und mit wenig Overhead lösen willst: Desktop-App ↔ Windows-Service, geringe Latenz, Zugriff über Windows-Rechte, ohne Firewall-/Portmanagement.

Ein Umdenken ist sinnvoll, wenn du die Grenzen absehen kannst:

  • Cross-Platform (Linux/macOS-Services) wird wichtig: Dann sind TCP/HTTP-basierte Schnittstellen oft konsistenter im Betrieb.
  • Observability wird Standardanforderung: Tracing, Proxies, Gateways, zentrale Metriken sind mit HTTP/gRPC meist einfacher anschlussfähig.
  • Skalierung über Hosts: Remote-Pipes existieren, aber Betrieb/Fehlersuche werden schnell unangenehm, wenn das System eigentlich verteilt gedacht ist.

Der Punkt ist nicht „Pipes sind schlecht“. Der Punkt ist: Pipes sind ein sehr gutes Werkzeug für einen klar abgegrenzten lokalen Integrationspunkt. Sobald du Richtung verteiltes System rutschst, zahlst du Betriebskosten an einer Stelle, die du nicht im Blick hattest.

Umsetzbare Priorität statt Allgemeinplatz

Wenn du nur eine Sache als Nächstes fixen willst: Mach Stop/Shutdown robust gegen „verbunden, aber still“. Das ist der Randfall, der Wartungsfenster sprengt, Services im Stop blockiert und dir die teuersten Support-Stunden verursacht. Erst danach lohnt es, über Performance, Parallelität oder „noch weniger Zeilen“ zu reden.

Wenn ihr den bestehenden IPC-Kanal stabilisieren oder modernisieren müsst (Timeout-Design, Logging, Protokollrahmen, Security Descriptor, Testfälle), lässt sich das am schnellsten in einem kurzen technischen Austausch klären: Kontakt aufnehmen.

Quellen und weiterfuehrende Informationen

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

  1. Synchronous and Overlapped Pipe I/O – Win32 apps | Microsoft Learn (learn.microsoft.com)
    Unterschied zwischen synchroner und Overlapped Pipe-I/O: Asynchronität nur bei passendem Handle und OVERLAPPED-Struktur.
  2. ReadFile function (fileapi.h) – Win32 apps | Microsoft Learn (learn.microsoft.com)
    ReadFile hat keinen Timeout-Parameter; Overlapped-I/O und Cancel-Mechanismen werden als relevante Muster genannt.
  3. ConnectNamedPipe function (namedpipeapi.h) – Win32 apps | Microsoft Learn (learn.microsoft.com)
    ConnectNamedPipe-Race-Condition und Behandlung von ERROR_PIPE_CONNECTED, wenn der Client bereits verbunden ist.
  4. Named Pipe Server Using Overlapped I/O – Win32 apps | Microsoft Learn (learn.microsoft.com)
    Referenzmuster für Named-Pipe-Server mit Overlapped-I/O als Basis für kontrollierbares Warten/Shutdown.
  5. 2.3.31 FSCTL_PIPE_WAIT Request (download.microsoft.com)
    Timeout-Semantik beim Warten auf Pipe-Instanz (FSCTL_PIPE_WAIT) betrifft die Verfügbarkeitsphase, nicht den Read-Timeout.

Für dieses Thema sind auch Delphi Windows API und Named Pipe Timeout wichtig. Der Beitrag ordnet diese Aspekte verständlich ein und zeigt, worauf es im Alltag ankommt.

Projekt oder Modernisierungsvorhaben mit Net-Base besprechen.

Seuraava vaihe

Kun aiheesta muodostuu todellinen projekti, arkkitehtuuri, nykytila ja operointi on tarkasteltava yhdessä varhaisessa vaiheessa.

Emme tue pelkästään yksittäiskysymyksissä, vaan myös silloin, kun lähdekoodipalasista, legacy-aiheista tai portaali-ideoista halutaan muodostaa luotettava yrityshanke.

  • Nykytila, tavoitetila ja tekniset riskit arvioidaan yhdessä.
  • REST, tietojen käyttö, portaalit ja käyttöönotto eivät siirry myöhempään vaiheeseen.
  • Näette ajoissa, mikä vaihtoehto on taloudellisesti ja operatiivisesti kannattava.

Jaa artikkeli

Jaa tämä viesti suoraan

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

Sähköposti

Instagram avautuu uuteen välilehteen. Linkki ja lyhyt teksti kopioidaan ensin leikepöydälle.

Kirjoita kommentti

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