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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
| /*
* Problématique :
* Les tableaux, List, Collection et autres, contenus dans des objets
* sont facilement sérialisables en XML dans la version 2.0 du Framework.
* Mais les Framework 1.1 et 2.0 ne permettent cependant pas de sérialiser
* des objets issus de la classe : Dictionary, qui est une classe plus complexe.
*
* Objectifs :
* Sérialiser un Dictionary sous forme XML
* Désérialiser le document XML pour reconstituer le Dictionary
*
* Remarque :
* La sérialisation binaire n'est pas abordée ici.
*
* Solution proposée :
* Comme les Dictionary ne sont pas directement sérialisables en XML,
* il faut enrichir les Dictionary proposés, par héritage, pour leurs ajouter
* les méthodes nécessaires à leur sérialisation XML :
* - Le Framework 1.1 (Visual Studio 2003) permettait de personnaliser
* les Dictionary par héritage de spécialisation de la classe
* abstraite DictionaryBase.
* - Le Framework 2.0 (Visual Studio 2005) offre une autre approche.
* On peut hériter de l'interface IDictionary pour personnaliser
* son dictionnaire, et en héritant simultanément de l'interface
* IXmlSerializable, qui apporte la solution à notre besoin de
* sérialisation XML.
* De nombreuses méthodes semblent alors devoir être implémentées...
*
* Fonctionnement :
* L'objet "mesClients", issu de la classe "Clients", contient deux "Client".
* Elle est sérialisée dans le fichier : MonFichierXml1.xml
* Ce fichier est désérialisé pour reconstituer un objet "tesClients"
* qui est lui aussi sérialisé dans un autre fichier : MonFichierXml2.xml
* Reste ensuite à comparer les deux fichiers pour s'assurer que l'on a rien
* perdu au passage ...
* Les fichiers de sérialisation sont normalement identiques.
* Mais pas les objets "Client" qui ont perdu leur champs "private", normal.
*
* Remarque :
* De nombreuses classes du Framework 2.0 sont maintenant dites génériques.
* Cette généricité permet de limiter les objets contenus dans une collection
* par exemple.
* Cet exemple utilise des classes génériques.
*
* - Ancienne syntaxe
* using System.Collections;
* public Dictionary mesClients;
* Et on pouvait alors mettre presque n'importe quoi dans ce dictionnaire !
*
* - Nouvelle syntaxe
* using System.Collections.Generic;
* public Dictionary<String, Client> mesClients;
* On ne peut mettre que des Client dans ce dictionnaire, avec une clef String.
*
* Questions :
* - Quelques points restent ici sans réponse (questions dans le code).
* - Les événements d'erreur de la désérialisation semblent ne pas se déclencher !
* - Dans WriteXml, la clef du dictionnaire génère la balise <string>dur</string>,
* Comment obtenir <Clef>dur</Clef>, sans transformer le String en objet ?
* - Est-il possible de forcer la sérialisation d'un champs "private" : m_DateNaissance ?
* - L'utilisation de "using" comme instruction, afin de limiter la portée d'un variable
* Essayez de le supprimer dans "Sérialisateur", et la désérialisation plante !
*
* Si vous trouvez une solution à ces questions, je serais heureux d'en profiter.
* Si vous pensez à d'autres techniques pour résoudre tout, ou partie, de ce problème
* je serais content d'apprendre quelque chose de votre part. Merci à vous.
* Une partie du code a été reprise sur le site MSDN de Microsoft. Merci à eux.
* Si l'orthographe de ce document présente des lacunes, n'hésitez pas à m'en informer,
* je serais attentif à vos remarques. (C'est sûr qu'il y a quelques erreurs !)
*
* Environnement technique :
* - Windows XP Pro,
* - Visual Studio 2005,
* - C# 2.0,
* - XML.
*
*/
using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Xml.Serialization;
using System.Xml;
using System.IO;
namespace WindowsApplication1
{
public partial class Form1 : Form
{
/*
* Champs
*/
String NomFichier1 = "MonFichierXml1.xml";
String NomFichier2 = "MonFichierXml2.xml";
Clients mesClients;
Clients tesClients;
// Sérialisateur
XmlSerializer monSérialisateur = null;
/*
* Contructeurs
*/
public Form1()
{
InitializeComponent();
}
/*
* Méthodes événementielles
*/
private void Form1_Load(object sender, EventArgs e)
{
Client unClient;
// Création de la collection des clients
mesClients = new Clients();
// Ajout d'un client
unClient = new Client("100", "Durand", "Pierre", @"01/02/2003");
mesClients.Add("dur", unClient);
// Ajout d'un autre client
unClient = new Client("200", "Martin", "Jean", @"04/05/2006");
mesClients.Add("mar", unClient);
}
private void Sérialiser_Click(object sender, EventArgs e)
{
Sérialiseur(mesClients, NomFichier1);
MessageBox.Show("Consultez le fichier " + NomFichier1 + " afin de vérifier son contenu ...");
}
private void Désérialiser_Click(object sender, EventArgs e)
{
tesClients = Désérialiseur(NomFichier1);
Sérialiseur(tesClients, NomFichier2); // Pour vérification, par comparaison, avec NomFichier1.
MessageBox.Show("Comparez les fichiers " + NomFichier1 + " et " + NomFichier2 + " afin de vérifier leur identité...");
}
private void Quitter_Click(object sender, EventArgs e)
{
Application.Exit();
}
/*
* Méthodes
*/
void Sérialiseur(Clients parClients, String parNomFichier)
{
try
{
/*
* Création d'un sérialiseur de type : XmlSerializer
* spécifiant le type de classe sérialisable : Clients.
*/
monSérialisateur = new XmlSerializer(typeof(Clients));
// Paramétrage de l'écriture XML
XmlWriterSettings ParamètresSérialisation = new XmlWriterSettings();
ParamètresSérialisation.Indent = true;
ParamètresSérialisation.IndentChars = (" ");
/*
* Sérialisation
* On peut utiliser aussi simplement : StreamWriter, ou FileWriter.
*/
using (XmlWriter monEcrivain = XmlWriter.Create(parNomFichier, ParamètresSérialisation))
{
monSérialisateur.Serialize(monEcrivain, mesClients);
monEcrivain.Flush();
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + "\n" + ex.InnerException.Message);
}
}
Clients Désérialiseur(String parNomFichier)
{
/*
* Création d'un sérialiseur de type : XmlSerializer
* spécifiant le type de classe sérialisable : Clients.
*/
monSérialisateur = new XmlSerializer(typeof(Clients));
// If the XML document has been altered with unknown
// nodes or attributes, handles them with the
// UnknownNode and UnknownAttribute events.
monSérialisateur.UnknownNode +=new XmlNodeEventHandler(monSérialisateur_UnknownNode);
monSérialisateur.UnknownAttribute += new XmlAttributeEventHandler(monSérialisateur_UnknownAttribute);
// Paramétrage de l'écriture XML
XmlReaderSettings ParamètresSérialisation = new XmlReaderSettings();
ParamètresSérialisation.ConformanceLevel = ConformanceLevel.Fragment;
ParamètresSérialisation.IgnoreWhitespace = true;
ParamètresSérialisation.IgnoreComments = true;
// On peut utiliser aussi simplement : StreamReader, ou FileReader.
XmlReader monLecteur = XmlReader.Create(parNomFichier, ParamètresSérialisation);
/*
* Uses the Deserialize method to restore the object's state
* with data from the XML document.
*/
return (Clients)monSérialisateur.Deserialize(monLecteur);
}
/*
* Gestionnaires d'erreurs
*/
private void monSérialisateur_UnknownNode(object sender, XmlNodeEventArgs e)
{
MessageBox.Show("Noeud inconnu : " + e.Name + "\t" + e.Text);
}
private void monSérialisateur_UnknownAttribute(object sender, XmlAttributeEventArgs e)
{
System.Xml.XmlAttribute attr = e.Attr;
MessageBox.Show("Attribut inconnu : " + attr.Name + "='" + attr.Value + "'");
}
}
}
public class Clients : IDictionary<String, Client>, IXmlSerializable
/*
* Toutes les interfaces de IDictionary sont implémentées par
* simple "re-branchement" aux méthodes de : Dictionary.
* La seule partie "créative" concerne les méthodes
* de IXmlSerializable : GetSchema, WriteXml et ReadXml.
*/
{
public IDictionary<String, Client> monDictionnaire;
public Clients()
{
monDictionnaire = new Dictionary<String, Client>();
}
#region IDictionary<string,Client> Membres
public void Add(string key, Client value)
{
monDictionnaire.Add(key, value);
}
public bool ContainsKey(string key)
{
return monDictionnaire.ContainsKey(key);
}
public ICollection<string> Keys
{
get { return monDictionnaire.Keys; }
}
public bool Remove(string key)
{
return monDictionnaire.Remove(key);
}
public bool TryGetValue(string key, out Client value)
{
return monDictionnaire.TryGetValue(key,out value);
}
public ICollection<Client> Values
{
get { return monDictionnaire.Values; }
}
public Client this[string key]
{
get
{
return monDictionnaire[key];
}
set
{
monDictionnaire[key] = value;
}
}
#endregion
#region ICollection<KeyValuePair<string,Client>> Membres
public void Add(KeyValuePair<string, Client> item)
{
monDictionnaire.Add(item);
}
public void Clear()
{
monDictionnaire.Clear();
}
public bool Contains(KeyValuePair<string, Client> item)
{
return monDictionnaire.Contains(item);
}
public void CopyTo(KeyValuePair<string, Client>[] array, int arrayIndex)
{
monDictionnaire.CopyTo(array, arrayIndex);
}
public int Count
{
get { return monDictionnaire.Count; }
}
public bool IsReadOnly
{
get { return monDictionnaire.IsReadOnly; }
}
public bool Remove(KeyValuePair<string, Client> item)
{
return monDictionnaire.Remove(item);
}
#endregion
#region IEnumerable<KeyValuePair<string,Client>> Membres
public IEnumerator<KeyValuePair<string, Client>> GetEnumerator()
{
return monDictionnaire.GetEnumerator();
}
#endregion
#region IEnumerable Membres
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return monDictionnaire.GetEnumerator();
}
#endregion
#region IXmlSerializable Membres
public System.Xml.Schema.XmlSchema GetSchema()
{
return null;
}
public void ReadXml(System.Xml.XmlReader reader)
{
reader.Read(); // move past container
while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
{
String key = (String)new XmlSerializer(typeof(String)).Deserialize(reader);
reader.MoveToContent();
Client value = (Client)new XmlSerializer(typeof(Client)).Deserialize(reader);
reader.MoveToContent();
monDictionnaire.Add(key,value);
}
}
public void WriteXml(System.Xml.XmlWriter parEcrivain)
{
foreach(KeyValuePair<String, Client> unePaire in monDictionnaire)
{
new XmlSerializer(typeof(String)).Serialize(parEcrivain, unePaire.Key); // Comment remplacer ici <string> par <Clef> ?
new XmlSerializer(typeof(Client)).Serialize(parEcrivain, unePaire.Value);
}
}
#endregion
}
public class Client
{
/*
* Ce champs sera sérialisé, car il est public
* Mais le nom de la balise n'est pas joli pour XML !
*/
public String m_CodeClient;
/*
* Ce champs sera sérialisé, car il est public
* Mais le nom de la balise est modifié
* pour être plus joli dans XML !
*/
[XmlElement(ElementName="NomClient")]
public String m_NomClient;
/*
* Celui-ci ne sera pas sérialisé, car il est privé
* mais la propriété : PrénomClient, permettra la sérialisation !
*/
private String m_PrénomClient;
/*
* Ce champs ne sera pas sérialisé du tout
* car il est privé, sans propriété ...
*/
private String m_DateNaissance; // Est-il possible de sérialiser ce champs, privé, par un attribut particulier ?
public Client()
{ }
public Client(String parCodeClient, String parNomClient, String parPrénomClient, String parDateNaissance)
{
m_CodeClient = parCodeClient;
m_NomClient = parNomClient;
PrénomClient = parPrénomClient;
m_DateNaissance = parDateNaissance;
}
public String PrénomClient
{
get { return m_PrénomClient; }
set { m_PrénomClient = value; }
}
} |
Petit coup de main xml
Répondre avec citation
)
Partager