Discussion :

[Majorlamda]

Bonjour à tous

Cela fait 2 jours que je planche sur ce problème mais je n'arrive pas à le résoudre.

Dans une partie de mon application, j'ai un flux d'actu. Chaque actu représente une image, un titre et une description. Je dois sauvegarder ce flux pour qu'il soit visible en mode déconnecté. Pas de problème pour sauvegarder les titres et description mais pour les images c'est une autre affaire !

J'ai eu beau retourné internet entier, je n'y arrive pas.

Le topic qui m'a plus rapproché de la solution est celui-ci :

http://social.msdn.microsoft.com/For...1-cd0c5f2520bc

Mais mon soucis est que cela marche pour une image, mais moi je dois en enregistrer plusieurs.

A chaque ajout d'un item dans mon flux, j'ajoute dans une liste l'url. Et je traite ensuite chaque image pour toutes les enregistrer.


Merci par avance pour votre aide

[DotNET74]

Salut,

le code du lien pour enregistrer ton image semble correcte donc je suppose que tu as fait une boucle sur toutes tes images.....

Et que ce passe t il exactement ?

[Majorlamda]

Oui le code est correct pour une image.
Pour la boucle :

Code :

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

1
2
3
4
5
6
 while (j < listImage.Count)
                    {
 
                        SauvegardeImageInfoIS(listImage[j]);
                        j++;
                    }

Et je rencontre une erreur à :

Code :

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

while (0 < (count = stream.Read(buffer, 0, buffer.Length)))

qui est :

Can not access a disposed object.
Object name: 'MS.Internal.InternalMemoryStream'.

Un problème de mémoire ?

[DotNET74]

peux tu mettre le code complet de la boucle et de la procédure SauvegardeImageInfoIS ?

Merci

[Majorlamda]

Oui pas de soucis.

La fonction Sauvegarde :

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
 public void SauvegardeImageInfoIS(string Urlimage)
        {
            string test = Urlimage;
            string nameImage = System.IO.Path.GetFileName(Urlimage);
            ImagePath = "Images\\" + nameImage;
            using (IsolatedStorageFile myStore = IsolatedStorageFile.GetUserStoreForApplication())
            {
                if (myStore.FileExists(ImagePath))
                {
                    myStore.DeleteFile(ImagePath);
                }
 
                try
                {
                    m_webClient.OpenReadCompleted += new OpenReadCompletedEventHandler(webClient_OpenReadCompleted);
                    m_webClient.OpenReadAsync(new Uri(Urlimage,UriKind.Absolute));
                    Debug.WriteLine("Acquiring Image");
}
catch (IsolatedStorageException ex)
                {
                    Debug.WriteLine(ex.Message);
                }

Qui appelle ensuite webClient_OpenReadCompleted

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
 
void webClient_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
        {
            // Read complete
            int count;
            byte[] buffer = new byte[2048];
 
            Debug.WriteLine("Image Acquisition Complete");
 
            // Create (or replace) file and write image to it
            Stream stream = e.Result;
            using (IsolatedStorageFile isf = IsolatedStorageFile.GetUserStoreForApplication())
            {
                using (System.IO.IsolatedStorage.IsolatedStorageFileStream isfs = new IsolatedStorageFileStream(ImagePath, FileMode.Create, isf))
                {
                    count = 0;
 
                    while (0 < (count = stream.Read(buffer, 0, buffer.Length)))
                    {
                        isfs.Write(buffer, 0, count);
                    }
 
                    stream.Close();
                    isfs.Close();
                }
            }
 
            Debug.WriteLine("Image Saved");
 
        }

[danuz]

Mmm, un peu plus simplement.

Après chaque sauvegarde, rajoute ceci déjà :

Thread.Sleep(1);

ça permettra d'éviter des problèmes pour l'écriture de tes images .

Sinon, me concernant, voici comment je m'y prends dans ma dernière application pour sauvegarder des images :

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
 
 
private readonly IsolatedStorageFile _myStore = IsolatedStorageFile.GetUserStoreForApplication();
 
        /// <summary>
        /// 
        /// </summary>
        /// <param name="image">full image path</param>
        /// <param name="source"></param>
        private void Save(string image, Stream source)
        {
            IsolatedStorageFileStream fileStream = _myStore.CreateFile(image);
 
            BitmapImage bitmap = new BitmapImage();
            bitmap.SetSource(source);
            WriteableBitmap wb = new WriteableBitmap(bitmap);
 
            wb.SaveJpeg(fileStream, wb.PixelWidth, wb.PixelHeight, 0, 90);
            fileStream.Close();
        }

Après, pour pouvoir obtenir un stream :

Code :

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

1
2
3
4
5
 
  StreamResourceInfo sri = null;
  Uri uri = new Uri(imageUrl, UriKind.Relative);
  sri = Application.GetResourceStream(uri);
  Save(imageWithPath, sri.Stream);

Tu peux l'exécuter dans un Background Worker pour éviter d'avoir de mauvaises performances.

Ensuite, Tu n'es pas obligé de garder le nom de l'image tel quel, tu peux utiliser un GUID comme nom à la place (ça t'évitera des problèmes si dans ton flux tu as des images avec le même nom pour des items différents).

Voici en résumé les étapes à suivre :

1/ Tu récupères ton flux dans un objet temporaire
2/ Tu associes chaque image a un Guid (pour avoir son nom).
3/ Tu sauvegardes chaque image avec pour nom le guid qui lui est associé
4/ Tu associes les guids aux propriétés Image de tes items

Et c'est tout me semble-t-il !

[danuz]

Par rapport à ton code, tu peux passer le stream (e.Result) à ma méthode Save. Enfin, teste ce que tu peux, et fais nous un retour.

[DotNET74]

Je crois que ce qu se passe c'est que ton download se fait en parallèle de ta boucle qui doit continuer sans se poser la question si l'évènnement ..Completed est fini ou pas !

donc je mettrais bien un flag dans la boucle While afin d'autoriser le traitement de l'image j....

pour résumer:

1. Initialiser le flag àTrue au moment de l'abonnement au ...Completed
2. Initialiser le flag à False à la fin du traitement de l'évènnement ...completed.

A voir

[Majorlamda]

Je suis reparti sur ta solution Danuz que j'avais déjà trouvé auparavant, elle me paraissait le plus simple.

Je me retrouve donc toujours avec ma boucle :

Code :

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

1
2
3
4
5
6
while (j < listImage.Count)
                    {
 
                        SauvegardeImageInfoIS(listImage[j]);
                        j++;
                    }

Et cette fois-ci ce code :

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
public void SauvegardeImageInfoIS(string Urlimage)
        {
            string nameImage = System.IO.Path.GetFileName(Urlimage);
            ImagePath = "Images\\" + nameImage;
            using (IsolatedStorageFile myStore = IsolatedStorageFile.GetUserStoreForApplication())
            {
                if (myStore.FileExists(ImagePath))
                {
                    myStore.DeleteFile(ImagePath);
                }
 
                try
                {
                    StreamResourceInfo sri = null;
                    MessageBox.Show(Urlimage);
                    Uri uri = new Uri(Urlimage, UriKind.Absolute);
                    sri = Application.GetResourceStream(uri);
                   // Save(ImagePath, sri.Stream);
                    IsolatedStorageFileStream fileStream = myStore.CreateFile(ImagePath);
 
                    BitmapImage bitmap = new BitmapImage();
                    bitmap.SetSource(sri.Stream);
                    WriteableBitmap wb = new WriteableBitmap(bitmap);
 
                    wb.SaveJpeg(fileStream, wb.PixelWidth, wb.PixelHeight, 0, 90);
                    fileStream.Close();
                }
                catch (IsolatedStorageException ex)
                {
                    Debug.WriteLine(ex.Message);
                }
            }
        }

Il me semble que c'est identique à celui de Danuz (sauf que tu décomposes en deux parties). Après avoir essayer des points d'arrêts, il va dans la catch au niveau de cette ligne :

sri = Application.GetResourceStream(uri);

Une exception de première chance de type 'System.ArgumentException' s'est produite dans System.Windows.dll

[danuz]

Alors, n'oublie pas le Thread.Sleep(1); ça ne va pas perturber ton application, mais l'aider (^__^).

Sinon, le problème vient du paramètre. La méthode Application.GetResourceStream(uri) va chercher à lire dans le package. Si tu lui passes une Uri absolute, elle n'y parviendra pas, d'ou l'erreur que tu as.

Il faut en fait que tu sauves le stream après que l'image ait été téléchargée une première fois. (^__^).

[Majorlamda]

Ok pour le Thread.Sleep(1). Je l'ai ajouté.

Je suis repassé sur une urikind.relative par contre maintenant il bug à cette ligne.

"System.UriFormatException" ...

Il faut bien lui passer l'url de l'image présente sur le net qu'on veut enregistrer non ?

[danuz]

Pas que ça (^__^).

Il faut sauver l'image dans l'évent webClient_OpenReadCompleted. Tu as le stream de l'image dans cette méthode, donc, tu peux sauver à l'intérieur (^__^)

[Majorlamda]

Je suis complètement perdu je crois

[danuz]

Je vais rentrer là! Quand j'arrive, si personne n'y a encore répondu, je te fais un exemple détaillé ici. Ok? (^_^)

[Majorlamda]

Oui je veux bien! Merci bien

[DotNET74]

C'est ce que j'indiquais plus haut !

ton évènnement OpenReadCompleted se lève lorsque ton fichier (image) est complètement télécharger.

C'est à ce moment là que tu dois l'enregistrer dans l'IsolatedStorage.

Si tu fais ça tu n'as alors plus besoin de sauver toutes les images d'un coup puisqu'au fur et à mesure que l'utilisateur télécharge tu sauves les images.

[Majorlamda]

En fait, je comprend la démarche à suivre mais je ne vois pas exactement comment la réaliser de A à Z.

Danuz si tu pouvais me rédiger l'exemple détaillé dont tu parlais hier soir, cela m'aiderais beaucoup.

[DotNET74]

Hello,

personnellement je sauvegarderais systématiquement les images au fur et à mesure que tu les reçois.

Comme ça, pas de boucle de traitement et transparent pour l'utilisateur.

C'est quoi ton code de récupération des données sur le web ?

[Majorlamda]

Je voulais faire ça à la base mais je me suis confronté à un problème d'écriture.

J'ai un webclient qui télécharge un fichier php contenant du xml.
Je le parse pour en ressortir chaque item. Et en continue je stock chaque ligne dans un fichier. De base donc, je ne télécharge pas à proprement parler les images. J'applique ensuite chaque url d'image via binding à la source.

[DotNET74]

Ok,

mais tu télécharges bien les images pour les afficher ?