Discussion :

[ApprentiProgrammeur]

Bonjour à tous je suis un débutant en c#,

Alors voilà ce que j'aimerais réaliser c'est une méthode générique de désérialization j'ai fais comme ça pour le moment mais ça ne marche pas vraiment.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
public string charger<T>(T objectToSerialize, string xmlPath)
{
            StreamReader lecture = new StreamReader(xmlPath);
            XmlSerializer serializer = new XmlSerializer(typeof(T));
            T temp = (T)serializer.Deserialize(lecture);
            lecture.Close();
            return temp; 
}

Mon but était de retourner les valeurs de mon fichier pour pouvoir les utilisés mais il semblerait que le type ne va pas car il me dit que c'est impossible de convertir temp en string.

Merci de votre aide.

[ClaudeBg]

Salut
-----

J'ignore si c'est exactement ce que tu cherches, mais voici mes routines de sérialisation/désérialisation génériques qui fonctionnent dans un de mes programmes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
         //////////////////////////////////////////////////////////////////////////////////////////////
        //                            SÉRIALISE L'OBJET DANS UN FICHIER XML                         //
        //////////////////////////////////////////////////////////////////////////////////////////////
 #region SerializeXml
        //--------------------------------------------------------------------------------------------
        /// <summary>Sérialise un objet sérialisable dans un fichier Xml</summary>
        /// <typeparam name="T">Type de l'objet</typeparam>
        /// <param name="obj">Objet à sérialiser</param>
        /// <param name="fileName">Nom du fichier Xml</param>
        /// <returns>True si l'opération a réussi</returns>
        //--------------------------------------------------------------------------------------------
        public static bool SerializeXml<T>(T obj, string fileName)
        {
            bool result = false;                                            // par défaut, échec
 
            try
            {
                XmlSerializer serializer = new XmlSerializer(typeof(T));    // créer un sérialiseur de type requis
                using (var writer = new StreamWriter(fileName))             // créer écrivain de flux sur fichier
                {
                    serializer.Serialize(writer, obj);                      // Sérialiser l'objet
                }
                result = true;                                              // si on arrive ici, c'est que tout est OK
            }
            catch { }                                                       // erreur
 
            return result;                                                  // retourner résultat de l'opération
        }
 #endregion
 
        //////////////////////////////////////////////////////////////////////////////////////////////
        //                          DÉSÉRIALISE L'OBJET DEPUIS UN FICHIER XML                       //
        //////////////////////////////////////////////////////////////////////////////////////////////
 #region DeserializeXml
        //--------------------------------------------------------------------------------------------
        /// <summary>Désérialise un objet à partir d'un fichier Xml</summary>
        /// <typeparam name="T">Type d'objet à récupérer</typeparam>
        /// <param name="fileName">Nom du fichier Xml</param>
        /// <returns>Objet désérialiser, ou valeur par défaut si échec</returns>
        //--------------------------------------------------------------------------------------------
        public static T DeserializeXml<T>(string fileName)
        {
            T result = default(T);                                          // valeur par défaut en cas d'échec (pas forcément nullable)
 
            try
            {
                XmlSerializer serializer = new XmlSerializer(typeof(T));
                using (StreamReader reader = new StreamReader(fileName))
                {
                    result = (T)serializer.Deserialize(reader);
                }
            }
            catch {}
            return result;                                                  // retourner résultat, ou default si échec
        }
 #endregion

A+
Claude

[ApprentiProgrammeur]

Merci pour le code de la désérialization, pourriez vous m'expliquer comment m'en servir car je ne comprends pas comment ça marche. J'arrive à désérializer un fichier xml mais sans passer par une méthode générique.

A+

[-N4w4k-]

Apparemment:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Class1 c1 = SerializationTool.DeserializeXml<Class1>(filename1);
Class2 c2 = SerializationTool.DeserializeXml<Class2>(filename2);

En admettant que la classe que ClaudeBg a posté s'appelle "SerializationTool"..

[ApprentiProgrammeur]

Désolé je me suis mal fait comprendre en fait j'arrive à appeler la méthode mais ce que je ne comprends pas c'est comment récupérer une valeur... Merci de votre aide.

[-N4w4k-]

Pour désérialiser un fichier, il te faut une classe qui représente la structure de ton fichier. Dans mon message précédent, j'ai mis un exemple avec 2 de ces classes (Class1 & Class2). Je montre comment récupérer les données dans un objet à partir du chemin vers le fichier.

Le mieux est de te renseigner sur internet pour voir comment marche la serialization. Tu peux déjà regarder la méthode XmlSerializer.Deserialize sur msdn, elle te montrera un exemple complet.

[ApprentiProgrammeur]

D'acc, je vais faire quelques recherches sur le net en espérant trouver mon bonheur. Merci pour ces précisions A+

[ClaudeBg]

Salut
------

Comme l'a laissé supposer N4w4k , à mon avis tu as mal appréhendé quelque chose:

La sérialisation telle que celle dont on est en train de parler consiste à sauver un objet (classe par exemple) dans un fichier.

La désérialisation consiste à récupérer l'objet en question à partir du fichier.

Donc, utiliser une sérialisation/désérialisation typées consiste à permettre d'enregistrer sur disque un objet de type A et de récupérer un objet de type A.

En utilisant une désérialisation/désérialisation génériques, on peut préciser lors de l'appel le type d'objet à sérialiser et à désérialiser.

Évidemment, pour que ça fonctionne, il faut qu'on connaisse et qu'on précise le type en question, on ne peut évidemment pas récupérer un objet A à partir de la sérialisation d'un objet B.

Pour l'utilisation, la sérialisation s'effectue par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

ClassSerializer.SerializeXml(monObjet, fileName)

Note qu'il n'y a même pas besoin de préciser le type de l'objet (ici, monObjet) car le compilateur connait le type T de l'objet passé en paramètre, ici on va imaginer que le type de "monObjet" c'est "TypeMonObjet"

Pour récupérer cet objet, on fait (dans cet exemple) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

var monObjet = ClassSerializer.DeserializeXml<typeMonObjet> (fileName);

et on récupère "monObjet" identique à ce qu'il était au moment de sérialiser.

J'espère que c'est plus clair.

A+
Claude

[ApprentiProgrammeur]

Merci pour vos explications, je pense avoir compris. En fait si je fais appel à la méthode dé-sérialiser il va me restaurer la class que j'ai sérialiser, c'est bien ça ? A+

[ApprentiProgrammeur]

En fait c'est bon j'ai étudié plus attentivement vos explications et je viens de comprendre. J'ai réussi à récupérer toute les valeurs de mon fichier XML. Un grand merci à vous