Du thème du magazine à la pratique des projets
Pages de services et techniques pertinentes pour l'article
Le moment est discret : un service s’arrête, un auto-updater remplace des fichiers, le Gestionnaire des tâches reçoit un clic de trop – et c’est justement à ce moment-là qu’une INI est enregistrée. Au démarrage suivant, il n’y a pas de dialogue « Konfig fehlt », mais un vrai problème opérationnel : le service ne démarre pas, l’interface reste down, le ticket atterrit dans la mauvaise équipe, et au final quelqu’un trouve une INI de 0 octet dans le répertoire du programme.
Si vous devez décider de mettre en œuvre Delphi : INI/Config atomar aktualisieren, il ne s’agit que rarement de « Clean Code ». C’est un conflit d’objectifs : minimiser la logique d’E/S et des chemins d’erreur versus garantir un comportement fiable en cas de crash, de kill ou de coupure de courant. Qui écrit de la configuration dans des environnements proches de la production (Windows- und Linux-Services, serveurs de terminal, kiosque, tâches planifiées) ne peut souvent pas se permettre la variante naïve.
Ce billet suit un chemin de décision : quelles options existent, ce qu’elles font réellement en cas d’erreur, quels mécanismes Windows les sous-tendent (Write-through, Flush, remplacement atomique) et quelle première étape vous apporte immédiatement une sécurité opérationnelle – sans transformer une INI en grand projet.
Delphi : Mise à jour atomique des INI/Config en pratique
Avant de comparer des API, clarifiez la classe de risque. Ce n’est pas un exercice académique, mais cela détermine quel niveau de « sécurité en cas de plantage » vous devez réellement acquérir.
- Peu critique : positions des fenêtres, listes récemment ouvertes, mise en page de l’UI. Une réinitialisation est acceptable.
- Pertinent : points de terminaison, chemins, commutateurs de fonctionnalités, paramètres de locataire/licence. Une erreur génère du support et une perte de temps.
- Critique : paramètres de démarrage du service, contrôle des jobs, interrupteurs liés à la sécurité. Une erreur peut provoquer une indisponibilité ou neutraliser des mesures de protection.
À partir du niveau « pertinent », un remplacement atomique est en général un effort bien investi. À partir du niveau « critique », considérez qu’un schéma de stockage robuste est obligatoire — plus des tests qui ciblent réellement le moment du kill.
Options en comparaison : que se passe-t-il réellement en cas de crash ?
Le piège typique : on évalue les options selon « à quelle fréquence ça marche », et non selon « à quel point c’est cassé quand ça tourne mal ». La matrice suivante est donc formulée volontairement du point de vue de l’exploitation.
| Option | Effort d’implémentation | Comportement en cas de crash/kill | Pièges fréquents | Convient si … |
|---|---|---|---|---|
| Écrire directement dans le fichier cible | faible | Risque : état partiel, 0 octet, format invalide | Interruption en plein écrit ; scanners/indexeurs concurrents | La config est jetable et non critique au démarrage |
| Écrire dans un fichier temporaire, puis renommage/déplacement | moyen | Généralement cohérent, mais pas nécessairement « durable » sans flush | Fichier temporaire sur un autre volume ; Copy+Delete au lieu de Rename ; métadonnées en cache | Vous voulez l’atomicité, mais pas la garantie maximale de persistance |
| Temp + Flush + ReplaceFile (remplacement atomique) | moyen | Très robuste : ancien ou nouveau fichier, rarement un état intermédiaire | Violations de partage, droits/ACL, règle des volumes, chemin de sauvegarde | La config est pertinente/critique ou vous exploitez des services/kiosques |
| Journal/format transactionnel (append + commit) | élevé | Contrôle maximal (replay/rollback possibles) | Plus de tests, migration, outillage, rotation des logs | Nombreuses écritures, plusieurs processus d’écriture ou modifications auditables nécessaires |
Le conflit central : l’atomicité n’est pas la persistance
Beaucoup d’équipes s’arrêtent à « fichier temporaire + renommage » — compréhensible, car cela empêche l’écrasement direct. Mais la sécurité en cas de crash a deux niveaux :
- Atomicité : les lecteurs doivent voir soit la version ancienne, soit la version nouvelle, pas un état intermédiaire.
- Persistance („durable write“): Après une coupure de courant, la nouvelle version doit effectivement être présente sur le support de stockage — pas seulement dans le cache.
Windows tamponne typiquement les opérations d’écriture dans le cache système. Sans flush explicite, l’algorithme du cache décide du moment où les données sont écrites sur le support.[Quelle] Conclusion pratique : un schéma peut sembler « logiquement propre » et pourtant mal finir en cas de coupure d’alimentation si vous n’utilisez ni Write-through ni ne procédez à un flush.
Dans de nombreuses applications d’entreprise, l’atomicité est le levier le plus important (pas d’INI corrompue). La persistance devient critique là où des appareils sont brutalement mis hors tension, dans des environnements embarqués/industriels, ou lorsque les modifications de configuration sont rares mais entraînent des conséquences maximales en cas d’erreur.
La voie robuste : fichier temporaire, Write-through/Flush, puis remplacement atomique
Si vous optez pour la « robustesse », votre schéma de stockage doit être clair et vérifiable. Pas une utilité magique, mais une suite d’étapes vérifiables :
- Créer le fichier temporaire dans le dossier cible (ou au moins garantir qu’il se trouve sur le même volume). C’est la condition pour qu’un Replace soit vraiment un Replace — et non un Copy+Delete.
- Écrire complètement dans le fichier temporaire (y compris le choix d’encodage ; fermer le fichier pour que les tampons atteignent la pile I/O).
- Déclencher la persistance : ouvrir le handle de fichier avec
FILE_FLAG_WRITE_THROUGHet/ou appelerFlushFileBuffers. Microsoft décrit le Write-through comme un écriture « sans délai » depuis le cache ; pour la durabilité des métadonnées et la durabilité de bout en bout, la documentation CreateFile renvoie toujours à FlushFileBuffers.[Quelle] - Remplacer de manière atomique : utiliser
ReplaceFileW(optionnellement avec sauvegarde). Cela encapsule l’échange en une opération et est conçu pour cet usage. - Rendre visibles les chemins d’erreur : Que se passe-t-il en cas de Sharing-Violation, de droits insuffisants ou d’absence du fichier cible ? Consignez l’étape et le code d’erreur.
Un détail n’est pas négociable : ReplaceFileW exige que le fichier remplacé et le fichier de remplacement se trouvent sur le même volume.[Quelle] C’est précisément pourquoi « Temp in %TEMP% » est un paramètre par défaut dangereux : dans des scénarios Roaming/VDI ou avec des profils redirigés, le volume peut varier, et votre étape « atomique » ne l’est plus du tout.
Delphi-INI-Klassen korrekt einordnen : UpdateFile n’est pas votre ancre de sécurité en cas de crash
TIniFile et TMemIniFile sont pratiques et suffisent dans de nombreux projets. La différence est, en gros : TMemIniFile accumule les modifications en mémoire et écrit de manière groupée ; TIniFile travaille plus près du fichier (selon l’implémentation/version). Pour la sécurité en cas de crash, ce qui compte vraiment est ce que « Update » signifie au final.
La documentation RAD-Studio de System.IniFiles.TIniFile.UpdateFile décrit l’écriture de données tamponnées, mais relativise l’effet historiquement (sous NT cela pourrait « ne pas avoir d’effet »).[Source] Conclusion pratique : UpdateFile est utile pour le problème du « vidage des tampons Delphi », mais ce n’est pas l’étape finale pour les scénarios de crash ou de coupure d’alimentation.
Si votre configuration est critique pour l’exploitation, traitez l’écriture des INI comme toute autre modification persistante : vous avez besoin d’un modèle qui fonctionne correctement au niveau des handles de fichier et du système de fichiers.
ReplaceFileW oder MoveFileEx? Décidez selon la sémantique
Les deux approches peuvent « remplacer », mais la sémantique n’est pas identique. Ce sont ces nuances qui déterminent si votre support verra plus tard un « cassé sporadique » ou un « code d’erreur clair ».
ReplaceFileW : remplacement avec sauvegarde optionnelle
ReplaceFileW est conçu pour le cas d’utilisation « remplacer le fichier cible par un fichier de remplacement ». Vous pouvez demander la création d’un fichier de sauvegarde et, dans de nombreux cas, préserver les attributs de l’objet cible. Pour une configuration, cela convient souvent, car une sauvegarde permet le rollback le plus rapide en cas d’erreur — même sans débogueur.
MoveFileEx : renommage/déplacement général, avec flags
MoveFileEx avec MOVEFILE_REPLACE_EXISTING peut également remplacer. Dans les en-têtes courants existe aussi MOVEFILE_WRITE_THROUGH, pour traiter l’opération de déplacement/remplacement en write-through. Le piège n’est pas tant « ça ne peut pas », mais « vous devez assembler vous‑même la sémantique souhaitée » (sauvegarde, attributs, gestion des erreurs, tests).
Pour une INI qui influence le démarrage d’un service, ReplaceFileW est souvent le choix le plus clair. Pour des cas très simples, MoveFileEx peut suffire — mais alors vous devez accepter et tester consciemment les conséquences (pas de sauvegarde, sémantique différente).
Pièges qui, en pratique, génèrent réellement des tickets
Fichier temporaire dans le mauvais répertoire (et soudain c’est Copy+Delete)
Si le fichier Temp et la cible ne se trouvent pas sur le même volume, l’échange ne peut pas être atomique. C’est particulièrement sournois, car cela « fonctionnait toujours » sur les postes des développeurs et ne se manifeste qu’en environnements clients (profils redirigés, mappage de lecteurs différent, App‑V/VDI).
AV/Indexer/Backup-Agent laissent la cible brièvement ouverte
Les fichiers de configuration sont souvent scannés ou indexés. Dans ce cas, Replace échoue sporadiquement avec une Sharing-Violation. Ce n’est pas une raison pour abandonner le modèle — mais c’est une raison pour consigner les codes d’erreur et implémenter un court réessai limité avec backoff (p. ex. quelques tentatives sur quelques centaines de millisecondes). Important : les réessais ne doivent pas bloquer l’arrêt ou l’arrêt du service.
ACL et propriété : après le Replace, les droits ne correspondent plus
Si le fichier d’origine a été créé par l’installateur avec des ACL particulières, un fichier nouvellement créé peut porter des permissions différentes. ReplaceFile peut préserver des attributs, mais ce n’est pas une excuse pour ne pas vérifier. Pour l’exploitation, ce qui compte au final, c’est : l’identité du service peut-elle lire et écrire après la mise à jour ? Prévoyez ce cas de test, en particulier pour Program Files vs. ProgramData.
Mehrere Writer: atomar ersetzt, aber logisch verloren
Un Replace atomique empêche un état « à moitié écrit », pas un écrasement logique. Si deux processus font « lire → modifier → écrire », le dernier gagne. Si vous avez vraiment deux writers (Service + outil d’administration), vous avez besoin de coordination : mutex, fichier de verrouillage ou un point central qui sérialise les écritures. Sinon vous ne résolvez qu’un problème et en créez un nouveau.
Approche de debugging : comment rendre le cas limite de crash reproductible
La résistance aux crashs ne se « croit » pas : il faut la provoquer. Un test exploitable n’est pas élégant, mais il est explicite.
- Écriture de stress : enregistrez en succession rapprochée et variez longueur/contenu pour produire différents motifs d’écriture.
- Hard Kill : terminez le processus brutalement pendant la sauvegarde (p. ex. taskkill /F). Pas de « Close », pas de « Exit ».
- Après chaque redémarrage, valider : le fichier ne doit pas faire 0 octet, il doit être analysable, les clés obligatoires doivent exister.
- Journalisation progressive : ne consignez pas « Save OK », mais : Temp créé, Temp écrit, Flush OK/code d’erreur, Replace OK/code d’erreur, Backup oui/non.
- Varier l’environnement : SSD/HDD, VM avec coupure d’alimentation brutale, profil de Terminal Server, partage réseau (si pertinent).
Si, dans les logs, vous ne voyez plus tard que « Settings saved », cela n’aide personne. En revanche, si vous voyez « Replace fehlgeschlagen: Sharing violation », la mesure suivante est claire : ajuster la fenêtre de retry, vérifier le chemin/le scanner, évaluer les concepts de verrouillage.
Quand le code robuste n’en vaut pas la peine — et ce qui reste néanmoins obligatoire
Il existe des projets pour lesquels un flux complet Replace/Flush est disproportionné : outil mono-utilisateur, configuration purement cosmétique, écritures rares, et une réinitialisation acceptable. Dans ce cas, un « enregistrement normal » peut être justifié.
Même dans ce cas, deux points ne doivent pas être négligés :
- Récupération au chargement : Si l’INI n’est pas analysable, ne pas interrompre brutalement. Définir des valeurs par défaut, éventuellement sauvegarder le fichier défectueux et le réécrire.
- Validation minimale : Contrôler les sections et clés obligatoires, afin qu’un état « à demi plausible » ne provoque pas des erreurs secondaires interprétées plus tard comme un problème réseau ou de base de données.
C’est le véritable levier d’efficacité : vous empêchez qu’un fichier texte corrompu devienne une interruption de service — indépendamment du fait que vous ayez déjà implémenté le chemin d’écriture le plus robuste.
Première étape : courte liste de contrôle pour la décision en équipe
- Le processus peut-il être arrêté brutalement pendant la sauvegarde ? (Service-Shutdown, Update, Kiosk) Si oui : prévoir un Replace-Pattern.
- La configuration est-elle critique au démarrage ? Si oui : remplacer de manière atomique et prévoir une option de sauvegarde.
- Le fichier se trouve-t-il réellement localement sur NTFS ? Si non : l’effort de test augmente, mais le modèle reste pertinent.
- Y a‑t‑il plusieurs écrivains ? Si oui : concevoir en plus un mécanisme de verrouillage/sérialisation.
- Les chemins d’erreur sont-ils visibles ? Si non : ajouter d’abord du logging au niveau des étapes.
Si vous répondez « oui » à deux points ou plus, il y a de fortes chances que le remplacement atomique vous évite des tickets qui n’apparaissent que sporadiquement — et sont donc particulièrement coûteux.
Conclusion : mettre à jour de façon atomique signifie prendre en compte l’exploitation
Les fichiers INI sont petits, mais leur impact ne l’est souvent pas. Un schéma robuste pour « Delphi : mise à jour atomique de l’INI/config » n’est pas un luxe : fichier temporaire dans le dossier cible, flush/write-through là où cela compte, et un échange atomique (typiquement ReplaceFileW) plus des chemins d’erreur traçables. Ainsi, en cas de problème, vous disposez non seulement d’un fichier intact, mais aussi d’une réponse à la question du support « Que s’est-il exactement passé ? »
Si vous souhaitez appliquer proprement le schéma sur l’existant (y compris stratégie de tests, concept de locking et chemin de migration pour plusieurs lieux de configuration), cela se clarifie le plus rapidement lors d’un bref alignement technique : Contactez-nous.
Sources et informations complémentaires
Les principaux constats techniques ont été mis en perspective éditoriale à partir des sources externes suivantes.
- Flushing System-Buffered I/O Data to Disk – Win32 apps | Microsoft Learn (learn.microsoft.com)
Windows met en tampon les écritures de fichiers ; sans Flush explicite, les algorithmes de cache déterminent quand les données atteignent réellement le support, c’est pourquoi FlushFileBuffers est pertinent pour les écritures durables. - CreateFileA function (fileapi.h) – Win32 apps | Microsoft Learn (learn.microsoft.com)
FILE_FLAG_WRITE_THROUGH décrit le comportement write-through dans CreateFile ; pour la durabilité des métadonnées, FlushFileBuffers est toujours référencé. - ReplaceFileW function (winbase.h) – Win32 apps | Microsoft Learn (learn.microsoft.com)
ReplaceFileW encapsule l’opération de remplacement d’un fichier et suppose que le fichier remplacé et le fichier de remplacement résident sur le même volume. - System.IniFiles.TIniFile.UpdateFile – RAD Studio API Documentation (docwiki.embarcadero.com)
TIniFile.UpdateFile est documentée comme un vidage (flush) des modifications mises en mémoire tampon et, dans son contexte historique, son comportement est nuancé pour les systèmes NT.
Pour ce sujet, le remplacement atomique de fichiers et Replacefilew Delphi sont également importants. L’article situe ces aspects de manière claire et précise ce qui importe au quotidien.
Discuter d’un projet ou d’une initiative de modernisation avec Net-Base.
Étape suivante
Lorsque le sujet devient un projet réel, l'architecture, l'existant et l'exploitation doivent être examinés ensemble dès le départ.
Nous n'intervenons pas seulement sur des questions ponctuelles, mais aussi lorsque des fragments de code source, des problématiques liées aux systèmes legacy ou des concepts de portail doivent se transformer en un projet d'entreprise robuste.
- L'état des lieux, l'état cible et les risques techniques sont évalués conjointement.
- REST, l’accès aux données, les portails et le déploiement ne sont pas reportés à des phases ultérieures.
- Vous identifiez tôt quelle voie est viable économiquement et opérationnellement.