Stockage de données Typés ?

**Lorenzo77** · 23/10/2008, 16h38

salut,

j'aimerais pouvoir stocker/lire dans un fichier externe des données sans perdre le Type.
est ce qu'il existe une classe permettant de faire ca ?
faut utiliser un fichier binaire ?

pour l'instant j'utilise un fichier XML mais a chaque sauvegarde/chargement je suis obligé de convertir toutes les données ... ca fait quand même une 20aine de données pour ligne ...

**DroP** · 23/10/2008, 16h39

Regarde du coté de la sérialisation, ca devrait répondre à ton problème

**Lorenzo77** · 23/10/2008, 16h48

j'ai déjà farfouillé du coté des classes ISerializable / IDeserializationCallback mais ca va être trop compliqué a mettre en place a cause des références sur d'autres types qui sont contenu dans la classe a sérialiser ... faudrait gérer l'ordre de la sérialisation/désérialisation et j'ai pas le niveau pour

**Lorenzo77** · 26/10/2008, 01h04

pas d'autre soluce ?

**StormimOn** · 26/10/2008, 09h23

La sérialisation binaire (BinaryFormatter) te permettrait de sauvegarder l'état de ton objet complètement, y compris les objets référencés par ton objet que tu veux sauvegarder.

**Lorenzo77** · 26/10/2008, 14h54

salut storminon,

justement, j'ai testé cette soluce cette nuit .... aprés avoir compris qu'il suffisait de mettre l'attribut [Serializable] a toutes les classes que l'on veut serialiser (m'a fallu quelques heures pour comprendre ca

)
le comportement bizarre c'est que je me retrouve avec un fichier binaire qui fait exactement la taille des données que l'on met dedans ... je pensais que la taille serait grandement réduite, mais non.

dans ma classe Chaine (juste pour stocker une chaine de test) je charge un fichier texte (source.txt) de 147.5Ko que je serialise dans un fichier (sourceBin.txt) ... celui ci fait 147.7Ko aprés ajout des données, en plus j'y retrouve mon texte tel quel

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 Chaine c1 = new Chaine();
 StreamReader sr = new StreamReader("source.txt");
 c1.chaineTest = sr.ReadToEnd();
 sr.Close();
 
 BinaryFormatter binaryFmt = new BinaryFormatter();
 FileStream fs = new FileStream("sourceBin.txt", FileMode.Create);
 binaryFmt.Serialize(fs, c1);
 fs.Close();
 
 fs = new FileStream("sourceBin.txt", FileMode.Open);
 Chaine c2 = (Chaine)binaryFmt.Deserialize(fs, null);
 fs.Close();

c'est normal ce genre de comportement ?

**StormimOn** · 26/10/2008, 15h11

Oui c'est normal. La sérialisation binaire stocke dans un fichier les données brutes contenues dans un objet. Si tu as une chaîne ça ne me surprend pas que tu la retrouves en clair dans le fichier.

Et pour ce qui est de la taille du fichier, la sérialisation binaire ne compresse pas les données. La taille du fichier sera du même ordre que la taille de l'objet en mémoire.

Après libre à toi de compresser/chiffrer le fichier résultant

**Lorenzo77** · 26/10/2008, 15h19

merci

donc pour le coup si je veux réduire la taille je suis bon pour implémenter sur mes classes l'interface ISerializable et y integrer la compression/décompression.

**smyley** · 26/10/2008, 17h37

Envoyé par Lorenzo77

donc pour le coup si je veux réduire la taille je suis bon pour implémenter sur mes classes l'interface ISerializable et y integrer la compression/décompression.

A ta place j'aurai plutôt d'abord fait une serialization binaire puis j'aurai compressé le résultat avec un stream genre GZipStream dans System.IO.Compression. Implémenter ISerializable dans toutes les classes va être une horreur à coder ... (et ça brise un peut le but de se simplifier la vie avec [Serializable])

**Lorenzo77** · 26/10/2008, 20h37

ben décidément ... je dois vraiment aimer compliquer tout

concernant la compression/décompression des données de FileStream.Serialize / Deserialize :
-est ce qu'il serait logique d'avoir dans la classe a sérialiser 2 fonctions statiques (une pour sauvegarder/compresser et l'autre pour charger/décompresser) pour le gérer directement (avec comme attribut le fichier binaire) ?
-ou est ce qu'il est préférable d'avoir une sur-couche a cette classe pour remplir ce genre de fonction ?
-ou alors carrément créer une interface que les classes devront implémenter ?

tu as une idée sur ce qui parait le plus logique et surtout le plus propre niveau POO ?

**StormimOn** · 26/10/2008, 20h59

Tu peux facilement factoriser le code sur quelque chose d'aussi simple. Par exemple, une classe avec 2 méthodes statiques : une qui sérialise, compresse et une qui décompresse, désérialise. Car l'opération est indépendante du type après tout, et comme ça tout le monde en profite sans avoir à recoder la chose dans chaque classe à sérialiser.

Cela pourrait donner

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
public static class SerializeManager
{
    private static BinaryFormatter _formatter = new BinaryFormatter();
 
    public static void Serialize(string file, object o)
    {
        // On sérialise
        using (FileStream fs = new FileStream(file, FileMode.Create))
        {
            _formatter.Serialize(fs, o);
        }       
 
        // On compresse ensuite le fichier
        ...
    }
 
    public static object Deserialize(string file)
    {
        // On décompresse le fichier
        ...
 
        // On désérialise
        using (FileStream fs = new FileStream(file, FileMode.Open))
        {
           return _formatter.Deserialize(fs);
        }
    }
}

Ensuite, les classes à sérialiser peuvent avoir des méthodes Save/Load, qui feront appels aux méthodes statiques précédentes.

**Lorenzo77** · 27/10/2008, 06h19

tout simplement, merci

--------------
je viens de faire quelques tests de la classe en incluant la compression avec GZipStream toujours sur les données du fichier texte (147.5Ko) et je dois dire que les résultats sont ... bof ... le fichier qui contient pourtant que du texte (donc ce compresse trés bien) fait 53.6Ko aprés compression ... c'est franchement mauvais.
pour info : avec winrar je descend a 35Ko et avec 7zip a 42.4Ko
l'avantage de GZipStream c'est sa vitesse.

**smyley** · 27/10/2008, 11h37

et avec DeflateStream ?

**Lorenzo77** · 27/10/2008, 14h53

pas la moindre différence, les 2 utilisent le même algo pour la compression/decompression

par contre j'ai trouvé un projet qui permet d'utiliser la compression de 7zip avec le C# ... manquerait que le même pour supporter toutes les fonctionnalités des archives rar

**smyley** · 27/10/2008, 15h40

Je suis plutôt du genre à déconseiller l'utilisation de 7zip pour autre chose qu'un archiveur ... En fait j'ai eu l'occasion de l'utiliser pour mon projet (DreamShield) et au final j'ai été déçu. C'est clair, ça compresse vraiment bien mais question vitesse/utilisation de la mémoire, c'est horrible et infernal ... A moins que 100 ko de moins rapportent 10000 €, ...

**Lorenzo77** · 27/10/2008, 18h18

je confirme, niveau vitesse c'est le plus lent et de beaucoup, par contre en compression solide et en taux de compression sur certain type de données il est loin devant.

pour ca qu'il serait utile d'avoir la meme chose avec winrar ...

**smyley** · 27/10/2008, 18h57

Peut être avec #ziplib ? (j'ai pas testé récemment, mais il y a 4 ans ça marchait bien ...)

**Lorenzo77** · 28/10/2008, 01h40

j'ai déja fait plusieurs recherches et il n'y a rien pour winrar ... vu qu'il n'est pas ouvert/libre, ca n'a rien d'étonnant.

**smyley** · 28/10/2008, 01h45

je parlais de tester la #ziplib pour tester le rapport vitesse/compression ... j'ai bien supposé qu'il n'existait rien pour winrar, du moins, on peut décompresser librement une archive rar (avec unrar) mais pas compresser.