Serialiser un ImageSource

Version imprimable

Bonjour,

J'ai une application qui génère des miniatures de fichiers. Ce traitement étant assez long, je souhaite essayer de crée un fichier qui contiendrait en cache l'image du fichier associée au chemin de celui-ci. Une sorte de "Thumbs.db" du pauvre.

J'ai donc une classe ThumbnailsCache qui contient une liste de Thumbnail. Je cherche à sérialiser mon objet ThumbnailsCache

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
92
using System;
using System.Xml.Serialization;
using System.Windows.Media;
using System.Collections;
 
namespace Toto
{
    [XmlRoot("thumbnailsCache")]
    [XmlInclude(typeof(ImageSource))] 
    public class ThumbnailsCache
    {
        ArrayList cacheList;
 
        /// <summary>
        /// Constructeur par défaut
        /// </summary>
        public ThumbnailsCache()
        {
            cacheList = new ArrayList();
        }
 
        /// <summary>
        /// Ajout d'un Thumbnail à liste
        /// </summary>
        /// <param name="th">La Thumbnail</param>
        /// <returns></returns>
        public int AddThumb(Thumbnail th)
        {
            return cacheList.Add(th);
        }
 
 
        /// <summary>
        /// Tableau[] permettant la sérialisation, il est la "copie" de ArrayList cacheList;
        /// </summary>
        [XmlElement("thumbnail")]
        public Thumbnail[] Thumbnails
        {
            get
            {
                Thumbnail[] thumbs = new Thumbnail[cacheList.Count];
                cacheList.CopyTo(thumbs);
                return thumbs;
            }
            set
            {
                if (value == null) return;
                Thumbnail[] thumbs = (Thumbnail[])value;
                cacheList.Clear();
                foreach (Thumbnail th in thumbs)
                    cacheList.Add(th);
 
            }
        }
    }
 
 
    /// <summary>
    /// Classé utilisé pour le cache des icones
    /// </summary>
    public class Thumbnail
    {
        /// <summary>
        /// Le chemin du fichier
        /// </summary>
        [XmlAttribute("path")]
        public String path;
 
        /// <summary>
        /// Image du document ImageSource
        /// </summary>
        [XmlElement("icon")]
        public ImageSource image;
 
        /// <summary>
        /// Constructeur par défaut
        /// </summary>
        public Thumbnail() { }
 
        /// <summary>
        /// Constructeur
        /// </summary>
        /// <param name="_path">Le chemin</param>
        /// <param name="_img">L'image</param>
        public Thumbnail(String _path, ImageSource _img)
        {
            path = _path;
            image = _img;
 
        }
    }
}

Mais voilà, C# n'aime pas trop l'idée de sérialiser un ImageSource. J'ai essayé avec un String à la place pour la donné image, ca marche nickel... C'est bien la sérialisation de l'ImageSource qui pose problème...

Une idée ?

01/03/2010, 17h12
laedit

Il te faudrait convertir l'image (qui est constituées de bytes) en string.

Sinon, la classe BitmapFrame contient un Thumbnail de l'image.
01/03/2010, 17h16
alexadvance

Citation:

Envoyé par laedit

Il te faudrait convertir l'image (qui est constituées de bytes) en string.

J'ai essayé mais je ne sais pas comment faire. J'ai essayé avec un ImageSourceValueSerializer mais il me renvoit "System.Windows.Media.ImageSource" au lieu des données.

Citation:

Envoyé par laedit

Sinon, la classe BitmapFrame contient un Thumbnail de l'image.

Je vais fouiller vers là.. en écrivant les données brutes de l'image...
01/03/2010, 18h34
alexadvance

Bon... je galère... apparemment, il me suffirait de transformer mon ImageSource en un flux de donnée (via un MemoryStream) et stocker le flux...

Puis faire l'inverse à le désérialisation...

Mais je n'y arrive pas.. je tourne en rond pour obtenir le flux mémoire d'un ImageSource...
01/03/2010, 19h07
laedit

Tu n'as pas accès directement aux images ?

les "images" n'existent pas. Mon ImageSource est en fait la miniatures de mon fichier générée à partir de l'API Windows. Elles n'existent qu'en mémoire.

C'est jsutement pour cette raison que je voudrais éviter des les récréer à chaque fois; donc je voudrais créer un fichier texte ou je stockerai les données de l'image pour la recréer plus tard.
Je ne veux pas créer un fichier d'image car j'ai plusieurs images et je ne voudrais faire qu'un fichier.
C'est pour cela que je voudrais Serializer un tableau d'ImageSource.

Donc, j'essaie maintenant de stocker le "String" correspondant à l'ImageSource.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 //"image" est mon ImageSource MemoryStream memoryStream = new MemoryStream(); BitmapSource test = (BitmapSource)image; PngBitmapEncoder encoder = new PngBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create(test)); encoder.Save(memoryStream); memoryStream.Position = 0; StreamReader sr = new StreamReader(memoryStream); String rawdata = sr.ReadToEnd() return rawdata;
Donc, je stocke ainsi le "flux" de mon image... mais voilà, le String rawdata n'est pas tres compatible avec l'UTF-8, et je me prend donc une erreur de format sur mon XML à la relecture...

J'essaie donc maintenant d'encoder correctement ce flux, et de le décoder à la relecture... et je galère toujours et encore...

02/03/2010, 09h43
laedit

Tu peux indiquer un Encoding en paramètre du constructeur du StreamReader. Tu devrais finir par en trouver un compatible ;)
02/03/2010, 09h48
alexadvance

Même avec un "System.Text.Encoding.UTF8" qui correspond à l'encodage de mon XML, j'ai une erreur de caractère invalide...

Je me demandais si il n'y avait pas moyen de créer un champs CDATA, je vais peut etre fouiller dans ce sens....
02/03/2010, 09h51
laedit

L'encodage utf8 est-il celui indiqué par ton XML dans sa balise ou est-il celui qui est utilisé pour enregistrer le fichier ?

Car même s'il est indiqué dans la balise, le fichier n'est peut être pas enregistré en utf8.

Je me base effectivement sur la balise car je pensais qu'elle faisait loi.

Ensuite, vu que mon XML est généré par le XMLSerialize, je ne sais pas quel format il pourrait prendre...

Edit :

j'ai essayé ca, lors de la sérialisation
Code:

1 2 3 4 5 XmlSerializer serializer = new XmlSerializer(typeof(ThumbnailsCache)); TextWriter w = new StreamWriter(@"c:\temp\test.xml",false,System.Text.Encoding.UTF8); serializer.Serialize(w, CacheIcons); w.Close();
Mais c'est toujours le même problème

Bon alors... Serializer un ImageSource, c'est le bordel.. j'ai fini par trouver quelquechose en le transformant d'abord en Drawing.Bitmap.
Donc, finalement, j'ai décidé de stocker un Drawing.Bitmap dans ma classe. Je le retransformerai en ImageSource qu'a l'utilisation.

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
    /// <summary>
    /// Classé utilisé pour le cache des icones
    /// </summary>
    public class Thumbnail
    {
        /// <summary>
        /// Le chemin du fichier
        /// </summary>
        [XmlAttribute("path")]
        public String path;
 
        [XmlIgnore]
        public Bitmap thumb;
 
        [XmlElement("thumb")]
        public byte[] BitmapBytes
        {
            get
            {
                try
                {
                    MemoryStream ms = new MemoryStream();
                    thumb.Save(ms, ImageFormat.Bmp);
                    return ms.ToArray();
                }
                catch(Exception e)
                {
                    Console.WriteLine("Erreur de création du flux Bitmap : " + e.Message);
                    return null;
                }
            }
            set
            {
                thumb = new Bitmap(new MemoryStream(value));
            }
        }
 
        public Thumbnail(String _path, Bitmap _bmp)
        {
            path = _path;
            thumb = _bmp;
        }
 
        /// <summary>
        /// Constructeur par défaut
        /// </summary>
        public Thumbnail() 
        {
            path = null;
            thumb = null;
        }
 
    }

Ca marche bien mieux qu'avant, mais j'ai parfois des erreurs de mémoire protégés sur certaines serialisation ou déserilisation...

J'ai pas encore trouvé pourquoi.