Serialization / desérialisation sur disque avec possibilité de modifier le fichier XML avec notepad

Salut,

J'ai un problème qui nous rend dingue...

On a besoin de Sérialiser une liste sérialisable sur disque de sorte qu'il soit possible de modifier le fichier avec un simple notepad puis de pouvoir désérialialiser la bête sans que ça plante.

J'ai réussi à le faire en binaire mais en texte je n'y arrive pas, il y a des erreurs invisibles (peut être problème d'encodage).

Je ne cherche pas à corriger mon code mais plutôt à en trouver un tout fait qui a bien été éprouvé.

Connaitriez-vous un bonne adresse ?

D'avance merci

Laurent

Salut,

un simple code de ce genre ne passe t il pas ?
Code:

1 2 3 4 5 XmlSerializer xs = new XmlSerializer(typeof(MonType)); using (StreamWriter wr = new StreamWriter(MonFichier)) { xs.Serialize(wr, moninstance); }
StreamWriter possède des surcharges pour spécifier un encodage particulier.

Dans le doute, ce lien peut t'aider

Salut,

Merci pour ton aide mais tu verras que je vais un peu plus loi que cet exemple.

Voici les éléménts :

SerializableList.cs

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
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Xml.Serialization;
using System.Runtime.Serialization;
using System.Collections;
 
namespace Risk.RMX.Web.Objects.CommonLayer
{
    [XmlRoot("list")]
    [Serializable]
    public class SerializableList<T> : List<T>, IXmlSerializable
    {
        #region "Contructors"
        public SerializableList() : base() { }
        public SerializableList(IList<T> list) : base(list) { }
        public SerializableList(int capacity) : base(capacity) { }
        protected SerializableList(SerializationInfo info, StreamingContext context) { }
        #endregion
        #region IXmlSerializable Members
        public System.Xml.Schema.XmlSchema GetSchema()
        {
            return null;
        }
        public void ReadXml(System.Xml.XmlReader reader)
        {
            XmlSerializer itemSerializer = new XmlSerializer(typeof(T));
            bool wasEmpty = reader.IsEmptyElement;
            reader.Read();
 
            if (wasEmpty)
                return;
 
            while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
            {
                reader.ReadStartElement("item");
                T item = (T)itemSerializer.Deserialize(reader);
                reader.ReadEndElement();
 
                this.Add(item);
 
                reader.ReadEndElement();
                reader.MoveToContent();
            }
            reader.ReadEndElement();
        }
        public void WriteXml(System.Xml.XmlWriter writer)
        {
            XmlSerializer itemSerializer = new XmlSerializer(typeof(T));
 
            foreach (T item in this)
            {
                writer.WriteStartElement("item");
                itemSerializer.Serialize(writer, item);
                writer.WriteEndElement();
            }
        }
        #endregion
    }
}

SerializationTools.cs

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
 
        /// <summary>
        /// Method to convert a custom Object to an encoded XML string
        /// </summary>
        /// <param name="pObject">Object that is to be serialized to XML</param>
        /// <returns>XML string</returns>
        public static String SerializeObject<T>(T pObject,Encoding enc)
        {
            try
            {
                String XmlizedString = null;
                MemoryStream ms = new MemoryStream();
                XmlSerializer xs = new XmlSerializer(typeof(T));
                XmlTextWriter xmlTextWriter = new XmlTextWriter(ms, enc);
                xs.Serialize(xmlTextWriter, pObject);
                ms = (MemoryStream)xmlTextWriter.BaseStream;
                byte[] tMs = ms.ToArray();
                XmlizedString = enc.GetString(tMs);
                return XmlizedString;
            }
            catch (Exception e)
            {
                System.Console.WriteLine(e);
                return null;
            }
        }
        /// <summary>
        /// Method to reconstruct an Object from an XML encoded string
        /// </summary>
        /// <param name="pXmlizedString"></param>
        /// <returns></returns>
        public static T DeserializeObject<T>(String pXmlizedString,Encoding enc)
        {
            XmlSerializer xs = new XmlSerializer(typeof(T));
            MemoryStream ms = new MemoryStream(enc.GetBytes(pXmlizedString));
            XmlTextWriter xmlTextWriter = new XmlTextWriter(ms, enc);
            object oStringDeserialized = xs.Deserialize(ms);
            return (T)oStringDeserialized;
        }
        public static string ReadFileToString(string fileName, Encoding enc)
        {
            StreamReader sr = new StreamReader(fileName, enc);
            string toReturn = sr.ReadToEnd();
            sr.Close();
            return toReturn;
        }
        public static void WriteStringToTextFile(string fileName, string stringToWrite, Encoding enc) {
            FileStream fs = File.Open(fileName, FileMode.Create);
            StreamWriter sw = new StreamWriter(fs, enc);
            sw.Write(stringToWrite);
            sw.Close();
        }

Ma classe de base

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
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
 
namespace Risk.BHR.Objects.DomainLayer
{
    [Serializable]
    public abstract class DomainStringItem
    {
        private string _itemName;
 
        /// <summary>
        /// Nom de l'élément
        /// </summary>
        [XmlElement("ItemName")]
        public string ItemName {
            get
            {
                return _itemName;
            }
            set
            {
                _itemName = value;
            }
        }
        public override string ToString()
        {
            return _itemName;
        }
    }
}

Ma classe RiskClass

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
 
namespace Risk.BHR.Objects.DomainLayer
{
    /// <summary>
    /// Classe domaine de manipulation des classes de risque.
    /// </summary>
    [Serializable]
    public class RiskClass : DomainStringItem
    {
        public RiskClass(){ }
        public RiskClass(string itemName) {
            this.ItemName = itemName;
        }
    }
}

Mon programme de Test

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
 
    public class Configuration
    {
        public SerializableList<RiskClass> lstRiskClassList { get; private set; }
 
        public static void Main()
        {
            lstRiskClassList = new SerializableList<RiskClass>();
            lstFieldsToRequest = new SerializableList<SerializableList<URDField>>();
 
            SerializableList<String> lstTmp = new SerializableList<string>();
 
            lstTmp.Add("XXXXXX");
            lstTmp.Add("YYYYY");
            lstTmp.Add("ZZZZZ");
 
            foreach (var s in lstTmp)
            {
                lstRiskClassList.Add(new RiskClass(s));
            }
            Encoding enc = Encoding.Default;
            string SerializedList = SerializationTools.SerializeObject<SerializableList<RiskClass>>(lstRiskClassList, enc);
            SerializationTools.WriteStringToTextFile(configurationFilePath, SerializedList, enc);
            SerializedList = SerializationTools.ReadFileToString(configurationFilePath, enc);
            lstRiskClassList = SerializationTools.DeserializeObject<SerializableList<RiskClass>>(SerializedList, enc);
        }

S'il manque un truc, n'hésitez pas...

++

Laurent

Dans SerializableList.cs, il y a deux fois reader.ReadEndElement(); dans le while.

Wahoo tu es très fort...
Effectivement...

Ca soulève un nouveau problème. Etant donné qu'il y a un peut des éléments dans tous les sens, il faut que je définisse un complex type et en mode générique je le sens moyen...

Je crois que je vais décomplexifier mon bébé parceque là je m'embourbe...

++

Laurent

Citation:

Envoyé par Laurent Jordi

Wahoo tu es très fort...
Effectivement...

Ca soulève un nouveau problème. Etant donné qu'il y a un peut des éléments dans tous les sens, il faut que je définisse un complex type et en mode générique je le sens moyen...

Je crois que je vais décomplexifier mon bébé parceque là je m'embourbe...

++

Laurent

C'est le problème de la sérialization xml : c'est devient vite verbeux.
Par contre, tu peux tout de même alléger le xml au détriment du dynamisme.
RickClass est en quelque sorte "sous-Sérializé/sous-Désérializé" par un sous xml sérializer. On pourrait se limiter éviter d'y faire appel ou profit d'une lecture du xml plus classique. Tout ce cas, on perd le dynamisme car il faudrait gérer les éléments à la main dans le couple ReadXml/WriteXml.

edit : rien ne t'empêche non plus d'essayer de faire un objet façade "plus plat" pour la sérialization.

Oui c'est ce que je vais faire...
Quand je pense que dans ma jeunesse on aurait fait un piti fichier texte délimité et que ça m'aurait pris au moins 45 secondes...

Mais c'est :ccool: bo :ccool: le XML...