{"id":660,"date":"2014-06-25T23:43:37","date_gmt":"2014-06-25T21:43:37","guid":{"rendered":"http:\/\/dev.bratched.fr\/fr\/?p=660"},"modified":"2014-06-25T23:43:37","modified_gmt":"2014-06-25T21:43:37","slug":"images-et-isolated-storage-windows-phone-8","status":"publish","type":"post","link":"https:\/\/bratched.com\/fr\/2014\/06\/25\/images-et-isolated-storage-windows-phone-8\/","title":{"rendered":"Isolated Storage et Images sous Windows Phone 8"},"content":{"rendered":"

Je vous propose un petit tour d’horizon sur le stockage d’images dans l’Isolated Storage.<\/p>\n

Pour rappel, l’Isolated storage est l’emplacement r\u00e9serv\u00e9 \u00e0\u00a0votre application Windows Phone pour\u00a0le stockage de fichiers.<\/p>\n

Quelles sont les impl\u00e9mentations qui permettent de r\u00e9cup\u00e9rer une image d\u00e9j\u00e0 stock\u00e9e dans cet espace ? Quelles sont les m\u00e9thodes les plus efficaces ?<\/p>\n

L’impl\u00e9mentation classique (Windows Phone 7)<\/h1>\n

C’est l’impl\u00e9mentation standard \u00ab\u00a0old school\u00a0\u00bb : j’utilise GetUserStoreForApplication() et OpenFile pour lire un Stream. Le Stream est ensuite lu par le BitmapImage et renvoy\u00e9 dans une Action.<\/p>\n

public static void LoadImageFromStorage(string name, Action<BitmapImage> actionBitmap)\n{\n    using (IsolatedStorageFile myIsolatedStorage = IsolatedStorageFile.GetUserStoreForApplication())\n    {\n        if (myIsolatedStorage != null && myIsolatedStorage.FileExists(name))\n        {\n            IsolatedStorageFileStream fileStream = myIsolatedStorage.OpenFile(name, FileMode.Open, FileAccess.Read);\n            {\n                Deployment.Current.Dispatcher.BeginInvoke(() =>\n                {\n                    BitmapImage bitmapSource = new BitmapImage();\n                    bitmapSource.SetSource(fileStream);\n                    if (actionBitmap != null)\n                        actionBitmap(bitmapSource);\n                });\n            }\n        }\n    }\n}<\/pre>\n
Remarque 1<\/h2>\n
BitmapImage n\u00e9cessite de s’ex\u00e9cuter dans le ThreadUI principal, pour cela, on utilise<\/p>\n
Deployment.Current.Dispatcher.BeginInvoke(() =>\n<\/pre>\n
<\/p>\n
Remarque 2<\/h2>\n
Le Stream de l’isolated Storage\u00a0peut s’ex\u00e9cuter dans un Thread en arri\u00e8re plan, on ne peut pas ici utiliser une syntaxe comme celle ci dessous (qui permettrait de garantir la lib\u00e9ration m\u00e9moire du FileStream).<\/p>\n
using (IsolatedStorageFileStream fileStream = myIsolatedStorage.OpenFile(name, FileMode.Open, FileAccess.Read))\n{\n...\n}<\/pre>\n
Attention donc, car l’utilisation du using fermerait le FileStream avant que le ThreadUI ne puisse l’utiliser.<\/p>\n
Utilisation de la m\u00e9thode<\/h2>\n
L’utilisation de cette premi\u00e8re m\u00e9thode pourrait \u00eatre celle ci :<\/p>\n
IsolatedImageService.LoadImageFromStorage(\"TestImage.png\", b =>\n{\n    Image = (b as BitmapImage);\n});<\/pre>\n
(o\u00f9 image repr\u00e9sente\u00a0une propri\u00e9t\u00e9 de type BitmapImage)<\/p>\n
 <\/p>\n
L’impl\u00e9mentation Windows Phone 8 (async \/ await)<\/h1>\n
Windows Phone 8 permet l’ancienne syntaxe Windows Phone 7, mais ajoute \u00e9galement\u00a0tout une gestion de l’Isolated Storage avec\u00a0la nouvelle classe StorageFile.<\/p>\n
La classe StorageFile va proposer des actions asynchrones\u00a0assez efficaces.<\/p>\n
Ici, j’utilise GetFileFromApplicationUriAsync pour r\u00e9cup\u00e9rer en une seule instruction le fichier image de l’Isolated Storage.<\/p>\n
Le Stream est ensuite accessible avec OpenStreamForReadAsync();<\/p>\n
public static async Task<BitmapImage> LoadImageFromStorage2(string name)\n{\n    Windows.Storage.StorageFile storageFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri(\"ms-appdata:\/\/\/local\/\" + name));\n    BitmapImage image = null;\n    using (Stream stream = await storageFile.OpenStreamForReadAsync())            \n    {\n        using (MemoryStream ms = new MemoryStream())\n        {\n            await stream.CopyToAsync(ms);\n            await Task.Run(() =>\n            {\n                synchroUI.Send(_ =>\n                {\n                    image = new BitmapImage();                    \n                    image.SetSource(ms);\n                }, null);\n            });\n        }             \n    }\n    return image;\n}<\/pre>\n
Remarque 1<\/h2>\n
Le code suivant :<\/p>\n
DispatcherSynchronizationContext synchroUI = new DispatcherSynchronizationContext;\n...\n\nawait Task.Run(() =>\n            {\n                synchroUI.Send(_ =>\n                {\n<\/pre>\n
permet d’utiliser l’UIThread principal, obligatoire pour l’utilisation de BitmapImage. Il peut \u00eatre remplac\u00e9 par<\/p>\n
Deployment.Current.Dispatcher.BeginInvoke(() =>\n<\/pre>\n
Remarque 2<\/h2>\n
L’utilisation du MemoryStream permet d’\u00e9viter une fuite m\u00e9moire qui a lieu lorsque le Stream de l’IsolatedStorage reste bloqu\u00e9 dans le Thread de t\u00e2che de fond.<\/p>\n
C’est le flux de donn\u00e9es copi\u00e9 dans le MemoryStream qui va ensuite \u00eatre\u00a0utilis\u00e9 par le BitmapImage.<\/p>\n
 using (MemoryStream ms = new MemoryStream())\n        {\n            await stream.CopyToAsync(ms);\n<\/pre>\n
Remarque 3<\/h2>\n
Il est possible d’utiliser la syntaxe Using sur les Stream sans g\u00e9n\u00e9rer de fuites m\u00e9moire:<\/p>\n
 using (Stream stream = await storageFile.OpenStreamForReadAsync())\n<\/pre>\n
Appel de la m\u00e9thode<\/h2>\n
La m\u00e9thode peut alors \u00eatre appel\u00e9e de la fa\u00e7on suivante\u00a0 :<\/p>\n
Image = await IsolatedImageService.LoadImageFromStorage2(\"TestImage.png\");\n<\/pre>\n
(o\u00f9 Image est une propri\u00e9t\u00e9 de type BitmapImage)<\/p>\n
Une autre implementation async await Windows Phone 8<\/h1>\n
Il existe une variante du code pr\u00e9c\u00e9dent avec l’utilisation d’un IRandomAccessStream et du ReadAsync.<\/p>\n
public static async Task<BitmapImage> LoadImageFromStorage3(string name)\n{\n    Windows.Storage.StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;\n    Windows.Storage.StorageFile storageFile = await localFolder.GetFileAsync(name);\n    BitmapImage image = null;\n    IRandomAccessStream accessStream = await storageFile.OpenReadAsync();\n    using (Stream stream = accessStream.AsStreamForRead((int)accessStream.Size))\n    {\n        byte[] content = new byte[stream.Length];\n        await stream.ReadAsync(content, 0, (int)stream.Length);\n        await Task.Run(() =>\n        {\n            synchroUI.Send(_ =>\n            {\n                image = new BitmapImage();\n                using (var ms = new MemoryStream(content))\n                {                            \n                    image.SetSource(ms);                            \n                } \n            }, null);\n        });\n        stream.Close();\n    }\n    return image;\n}<\/pre>\n
Le ReadAsync lit les donn\u00e9es dans un buffer et utilise un MemoryStream pour son injection dans BitmapImage.<\/p>\n
Quelle m\u00e9thode est la plus rapide ?<\/h1>\n
J’ai repris le programme de Benchmark et test\u00e9 nos 3 m\u00e9thodes en chargeant une image importante (400ko, 1000 pixels x 1000 pixels) 100 fois.<\/p>\n
\"Benchmark<\/a><\/p>\n
Voici les r\u00e9sultats (moyennes apr\u00e8s une dizaine de tests cons\u00e9cutifs pour 100 appels):<\/p>\n