XmlDocument et mise à jour différée

Version imprimable

11/09/2017, 19h06
StringBuilder

XmlDocument et mise à jour différée

Bonjour,

Je travaille sur un programme qui effectue les opérations suivantes :
1/ Chargement d'un fichier XML sous forme d'un objet métier.
2/ Travail dans l'objet métier.
3/ Enregistrement de l'état de l'objet métier sous forme XML en lieu et place du fichier initial.

Ce programme est lancé par une tâche planifiée et tourne toutes les 10 minutes.

Parfois, il met plus de 10 minutes à tourner.

La tâche est paramétrée pour ne pas démarrer une seconde instance si la précédente n'est pas terminée.

Pourtant, parfois, le programme démarre une seconde fois alors que le fichier XML n'a pas encore été modifié.

J'ai en effet constaté que lorsque le lance le programme à la main, et que j'ouvre par exemple le fichier XML avec Notepad++, le fichier est parfois modifié plusieurs secondes, voir minutes, après la fin du programme.

Pourtant, XmlDocument n'est pas IDisposable, et Save() ne propose pas de Flush().

Qu'est-ce qui explique cette mise à jour différée ?

Comment l'empêcher ?

J'ai essayé de forcer myDoc = null suivi de GC.Collect() et SuppressFinalizer() mais ça ne change rien...
12/09/2017, 07h45
ericlm128

Citation:

le fichier est parfois modifié plusieurs secondes, voir minutes, après la fin du programme

Le problème ne semble donc pas venir de ton programme.
Je suis aussi plutôt surprit de ce que tu dit.

Mais notepad++ n'est pas très fiable pour cela.
J'utilise plutôt un programme en parallèle qui m'affiche les log de modifications avec FileSystemWatcher.
12/09/2017, 08h08
StringBuilder

Non, c'est bien mon programme (ou l'OS) qui pose problème : le fichier n'est réellement pas mis à jour immédiatement.
Les modifications ne sont pas flushées.

Exactement comme ce qu'il se passe avec un TextWriter qui ne serait pas convenablement disposé.
12/09/2017, 08h43
François DORIN

Bonjour,

Est-il possible que ton programme lance un autre processus ?

Citation:

Envoyé par François DORIN

Bonjour,

Est-il possible que ton programme lance un autre processus ?

Oui, il est multi-threadé.
Mais les "Task" lancées n'utilisent pas le fichier XML.
Et le "main" fait un "Task.WaitAll(tasks);"

Voici grossomodo ce que fait mon programme :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
    class Program
    {
        static void Main()
        {
            // [...] Un certain nombre d'opérations sans lien avec mon fichier XML
 
            InstanceCollection serverList = new InstanceCollection();
            serverList.Backup();
            serverList.Save();
 
            // [...] Un certain nombre d'opérations sans lien avec mon fichier XML
        }
    }
 
    public sealed class InstanceCollection
    {
        public InstanceCollection()
        {
            XmlDocument doc = new XmlDocument();
            doc.Load("servers.xml");
            try
            {
                Retention = int.Parse(doc.DocumentElement.SelectSingleNode("/backupsql/retention").InnerText, NumberStyles.Integer, CultureInfo.CurrentCulture);
            }
            catch
            {
                Retention = 5;
            }
            DateTime purgeDate = DateTime.Now.AddDays(-1 * (Retention + 1));
            foreach (XmlNode nd in doc.DocumentElement.SelectNodes("/backupsql/servers/server"))
            {
                instances.Add(new Instance(purgeDate, nd));
            }
        }
 
        public void Backup()
        {
            Task[] tasks = new Task[instances.Count];
            for (int i = 0, cpt = instances.Count; i < cpt; i++)
            {
                var value = i;
                tasks[value] = new Task(() => instances[value].Backup()); // Cette méthode n'utilise pas le fichier XML
                tasks[value].Start();
            }
            Task.WaitAll(tasks);
        }
 
        public void Save()
        {
            XmlDocument doc = new XmlDocument();
            doc.Load("servers.xml");
            XmlNode nbRetention = doc.SelectSingleNode("/backupsql/retention");
            if (nbRetention == null)
            {
                XmlNode ndRoot = doc.SelectSingleNode("/backupsql");
                nbRetention = ndRoot.OwnerDocument.CreateElement("retention");
                ndRoot.AppendChild(nbRetention);
            }
            nbRetention.InnerXml = this.Retention.ToString(CultureInfo.CurrentCulture);
 
            XmlNode ndInstances = doc.SelectSingleNode("/backupsql/servers");
            ndInstances.RemoveAll();
            foreach (Instance instance in instances)
            {
                XmlNode ndInstance = ndInstances.OwnerDocument.CreateElement("server");
                XmlAttribute attInstanceName = ndInstance.OwnerDocument.CreateAttribute("name");
                attInstanceName.Value = instance.Name;
                XmlAttribute attInstanceRestoreTo = ndInstance.OwnerDocument.CreateAttribute("restore");
                attInstanceRestoreTo.Value = instance.RestoreTo;
                foreach (Database database in instance.Databases)
                {
                    XmlNode ndDatabase = ndInstance.OwnerDocument.CreateElement("database");
                    XmlAttribute attDatabaseName = ndDatabase.OwnerDocument.CreateAttribute("name");
                    XmlAttribute attDatabaseLastFull = ndDatabase.OwnerDocument.CreateAttribute("lastfull");
                    XmlAttribute attDatabaseLastLog = ndDatabase.OwnerDocument.CreateAttribute("lastlog");
                    attDatabaseName.Value = database.Name;
                    attDatabaseLastFull.Value = database.LastFull.ToString("yyyy-MM-dd HH:mm:ss.fff", CultureInfo.CurrentCulture);
                    attDatabaseLastLog.Value = database.LastLog.ToString("yyyy-MM-dd HH:mm:ss.fff", CultureInfo.CurrentCulture);
                    ndDatabase.Attributes.Append(attDatabaseName);
                    ndDatabase.Attributes.Append(attDatabaseLastFull);
                    ndDatabase.Attributes.Append(attDatabaseLastLog);
                    ndInstance.AppendChild(ndDatabase);
                }
                ndInstance.Attributes.Append(attInstanceName);
                ndInstance.Attributes.Append(attInstanceRestoreTo);
                ndInstances.AppendChild(ndInstance);
            }
            doc.Save("servers.xml");
        }
    }

12/09/2017, 10h31
François DORIN
Citation:

Envoyé par StringBuilder

Oui, il est multi-threadé.

Je parlais bien de processus, pas de threads. Car un processus "fils" peut survivre au processus qui l'a lancé, contrairement à un thread.

Citation:

Envoyé par StringBuilder

J'ai essayé de forcer myDoc = null suivi de GC.Collect() et SuppressFinalizer() mais ça ne change rien...

Le SuppressFinalizer ne sert à rien. Il peut même empêcher les choses de fonctionner comme tu le souhaiterais.

Essai de faire un double appel à GC.Collect(). C'est à dire :
Code:

1 2 3 GC.Collect(); GC.Collect();
La raison à cela est que le ramasse-miette utilisé par le framework .Net est générationnel, et que le ramassage des objets avec Finalizer nécessite deux collections pour être effectué (je suis en train d'écrire un article là dessus, qui devrait donc paraître dans les semaines à venir, dès que j'aurais trouvé le temps de le finir). Néanmoins, je ne pense pas que cela vienne de là car tous les objets sont censés être collecter à la fin d'un programme.

Eventuellement, change de surchage pour la méthode Save. Il y en a une qui prend un stream. Tu créés un FileStream, tu sauvegardes, et ensuite, tu peux t'assurer de la libération correction du stream.
Code:

1 2 3 4 using(stream output = File.Open(path, FileMode.Create)) { doc.Save(output); }
Cela change-t-il quelque chose ?

Autre question : comme tu sembles manipuler des serveurs, le fichier est-il local ? Ou est-il sur un emplacement réseau ?
12/09/2017, 11h14
StringBuilder

Oui, il est bien en local.

Je vais tenter de passer par le FileStream. J'avais cette piste en tête, mais je me demande bien pourquoi le "Save()" qui doit utiliser un FilteStream en interne, ne le disposerait pas convenablement...