c2i.fr - WinRT

Demo du Unreal Engine sur WinRT

Wed, 29 Aug 2012 19:30:25 GMT

Développez sur Windows 8 sans Windows 8 : Virtual Labs

Thu, 09 Aug 2012 08:26:16 GMT

Je pense qu'ils existent depuis quelques temps mais je n'en avais jamais entendu parler.

Microsoft vous propose de tester le développement d'applications Windows 8 WinRT sans avoir installé Windows 8 grâce à des serveurs virtuels.

Près de 17 labs vous sont proposés en C#et en javascript. Cela va d'un simple Hello World à la gestion des roaming settings en passant par l'utilisation du semantic zoom et le Windows Store.

Après installation d'un ActiveX (oui, ca existe toujours ces bêtes là ;-)), vous aurez accès à une machine virtuelle vous permettant de tester la bête.

Très intéressante comme initiative, cela permet de démarrer simplement sous Windows 8.

NB : c'est la version Release Preview qui est proposée et pas la RTM. Donc je pense que ces labs risquent de disparaitre prochainement et/ou d'être mis à jour avec la version RTM.

http://msdn.microsoft.com/en-us/jj206431.aspx

Comment “cuisiner” une application Windows 8 avec XAML et C# en une semaine–Jour 4

Wed, 01 Aug 2012 15:21:03 GMT

Eric Vernié de Microsoft France continue l'adaptation de l'application de David Catuhe en Hmlt5/javascript pour Windows 8.

Il nous décrit entre autres la connection à Skydrive via le Live SDK.

Une série d'articles à lire quand vous débutez dans la programmation pour WinRT/Windows 8.

http://blogs.msdn.com/b/devosaure/archive/2012/07/31/comment-cuisiner-une-application-windows-8-avec-xaml-et-c-en-une-semaine-jour-4.aspx

Les API Win32 supportés par Metro

Tue, 31 Jul 2012 09:49:11 GMT

Suite à mon précédent article, certaines personnes se demandaient qu'elles étaient ces fameuses API Win32 supportées par Metro.

La liste complète est disponible ici : http://msdn.microsoft.com/en-us/library/windows/apps/br205757.aspx

Elles sont classées en 10 catégories :

Data : File System, Jet (et oui ;-)) et XML,
Devices : Device access, Game controllers, Windows portable devices,
Diagnostics : Debugging & error handling, Last Error, Windows Error Reporting, Windows Event,
Graphics : Direct2D, Direct3D, DirectWrite, DirectMath, Windows Imaging Component,
Multimedia : Camera, Core Audio, Media Foundation, XAudio2
Networking : Dynamic Host Configuration Protocol, Mobile Broadband, Windows Web Services, XML Http Request,
Printing & documents : Printing, XPS documents,
System : COM, Compression, DLLs, Info, Integers, Large Integer, Loader, Memory, RDP, Processes, Threads and synchronization, Time,
User interface : Accessibility, Globalization, Property system, Spell check, Strings, Text services framework, Windows animation,
Alternatives to Windows APIs

Comme vous pouvez le voir, il y a quand même pas mal d'APIs qui sont disponilbes nativement dans le framework. Donc à n'utiliser que si vous n'y arrivez pas avec du simple code C#/VB .NET (non, je ne parlerais pas de javascript ici ;-))).

Tester l'existence d'un fichier avec les API Win32 pour WinRT

Tue, 31 Jul 2012 09:50:24 GMT

C’est un sujet qui revient périodiquement quand vous développez une application pour Metro : comment savoir si un fichier existe déjà ?

Malheureusement, les API de WinRT ne proposent pas par défaut de méthode comme FileExists du Framework 1.0 de .NET ! Pour l’instant, je n’ai trouvé que deux possibilités.

Par itération

On effectue une itération sur l’ensemble des fichiers du StorageFolder et dès qu’on a trouvé le fichier recherché, on retourne true, sinon on retourne false. Cette méthode a été exposée par David Catuhe sur son blog et se résume ainsi :

public static class StorageFolderExtensions
{
    public static async Task<bool> FileExistsAsync(this StorageFolder folder, string name)
    {
        var files = await folder.GetFilesAsync();

        return files.Any(f => f.Name == name);
    }
}

L’inconvénient de cette méthode est que si votre dossier contient de nombreux fichiers, elle est “lente”.

La méthode brutale

Cette dernière essaye d’obtenir une référence vers le fichier et si il n’existe pas, une exception est déclenchée. Il suffit donc de mettre tout cela dans un try/catch :

public static class StorageFolderExtensions
{
    public static async Task<bool> FileExistsAsync(this StorageFolder folder, string name)
    {
        try
        {
            await folder.GetFileAsync(name);
            return true;
        }
        catch
        {
            return false;
        }
    }
}

L’intérêt est que cette méthode est plus rapide mais qu’elle est basée sur le déclenchement d’une exception, ce qui n’est pas du meilleur effet !

Il y a tout de même une autre solution : l’utilisation des API Win32

La méthode Win32

Depuis que je fais du .NET, j’avoue que je n’ai jamais plus utilisé les API Win32 comme on le faisait couramment avec Visual Basic 4-6. C’est donc avec une larme à l’oeil (souvenir, souvenir) que je me suis replongé dedans. Avec Metro, vous avez accès à une liste d’API Win32 triés sur le volet par Microsoft. Parmi celles-çi, il y en a une qui nous intéresse plus particulièrement ici : GetFieAttributesEx.

Nous allons donc créer une classe NativeOperations ou nous allons déclarer l’API et les structures qui sont nécessaires :

internal class NativeOperations
 {
     // ReSharper disable InconsistentNaming
     /// <summary>
     /// La déclaration de l'API GetFileAttributesEx
     /// </summary>
     /// <param name="lpFileName">Le nom du fichier recherché</param>
     /// <param name="fInfoLevelId">Quelles types d'info on recherche</param>
     /// <param name="lpFileInformation">Structure contenant les informations une fois l'API appelée</param>
     /// <returns></returns>
     [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
     [return: MarshalAs(UnmanagedType.Bool)]
     public static extern bool GetFileAttributesEx(
         string lpFileName,
         GET_FILEEX_INFO_LEVELS fInfoLevelId,
         out WIN32_FILE_ATTRIBUTE_DATA lpFileInformation);

     /// <summary>
     /// Type d'infos recherchées
     /// </summary>
     public enum GET_FILEEX_INFO_LEVELS
     {
         /// <summary>
         /// C'est la seule valeur autorisée avec WinRT
         /// </summary>
         GetFileExInfoStandard,
         /// <summary>
         /// Ne fonctionne pas sous WinRT => marqué Obsolete
         /// </summary>
         [Obsolete]
         GetFileExMaxInfoLevel
     }

     /// <summary>
     /// Structure contenant les informations sur le fichier
     /// </summary>
     [StructLayout(LayoutKind.Sequential)]
     public struct WIN32_FILE_ATTRIBUTE_DATA
     {
         public FileAttributes dwFileAttributes;
         public FILETIME ftCreationTime;
         public FILETIME ftLastAccessTime;
         public FILETIME ftLastWriteTime;
         public uint nFileSizeHigh;
         public uint nFileSizeLow;
     }

     // quelques valeurs d'erreurs succeptibles d'arriver
     private const int ERROR_FILE_NOT_FOUND = 2;
     private const int ERROR_PATH_NOT_FOUND = 3;
     private const int ERROR_ACCESS_DENIED = 5;

Maintenant, il ne nous reste plus qu’à utiliser cette API :

public static bool FileExist(string fileName)
{
WIN32_FILE_ATTRIBUTE_DATA fileData;
if (GetFileAttributesEx(fileName, GET_FILEEX_INFO_LEVELS.GetFileExInfoStandard, out fileData))
    return true;

// récupération de la dernière erreur (in the same thread of course ;-))
var lastError = Marshal.GetLastWin32Error();
if (lastError == ERROR_FILE_NOT_FOUND || lastError == ERROR_PATH_NOT_FOUND) return false;
// si c'est pas un fichier non trouvé, on lance une exception
if (lastError == ERROR_ACCESS_DENIED)
    throw new SecurityAccessDeniedException("Accès interdit");

throw new InvalidOperationException(string.Format("Erreur pendant l'accès au fichier {0}, code {1}", fileName, lastError));
}

Et ca marche, sans exception, sans itération, et c’est très rapide.

Limitations de cette démarche

Il y a une grosse limitation à cette démarche : elle ne fonctionne qu’avec le local storage ! Même si vous déclarez que vous avez le droit d’accéder au dossier des Images & co, il refusera d’y accéder (AccessDeniedException). Donc cela va très bien si vous recherchez des fichiers dans votre local Storage, mais vous pouvez la mettre à la poubelle si vous voulez rechercher dans un autre dossier (sniff, sniff).

En revanche, côté performances, il n’y a pas photo. J’ai effectué un test (IMPORTANT : en mode Release) sur un répertoire contenant plus de 600 fichiers. J’effectue une recherche d’existence de chacun des fichiers puis sur des noms de fichiers dont je sais pertinemment qu’ils n’existent pas. Résultat : je vais entre 5 et 10 fois plus vite avec les API Win32.

Il n’y a donc pas photo : si vous devez chercher régulièrement dans votre local Storage, utilisez cette méthode. En revanche, elle ne vous sera d’aucunes utilités ailleurs. Dommage !

En espérant que la version finale des API WinRT comportera une méthode optimisée…

De l'évolution du test de l'existence d'un fichier en .NET

Mon, 30 Jul 2012 06:52:14 GMT

.NET Framework 1.0, 2002 :

WINRT

Première solution (blog de David Catuhe)

2ème solution (brutale, "à la Mitsu" ;-))

10 ans de progrès...

Quelques liens sur le développement d'applications pour WinRT

Tue, 24 Jul 2012 07:11:37 GMT

Plutôt que de faire plusieurs billets courts, j'ai décidé ce matin de faire une petite compilation d'articles parus sur le développement d'applications pour Windows 8, WinRT. Au menu :

Jerry Nixon, Microsoft Developer Evangelist dans le colorado, nous parle de 8 "bizarreries" que l'on doit connaitre sur Windows 8 XAML avant de commencer à développer. Par exemple, l'absence de TileBrush, de StringFormat & co.

http://blog.jerrynixon.com/2012/07/8-quirks-windows-8-xaml-developers.html (anglais)

Toujours de Jerry Nixon, un article résumant les différentes façons d'accéder aux fichiers avec WinRT. Comment lire et écrire dans l'Isolated Storage, utiliser le File Picker, etc.

http://blog.jerrynixon.com/2012/06/windows-8-how-to-read-files-in-winrt.html (anglais)

Le blog officiel des développeurs d'applications Windows 8 vient de publier en français son article sur les tests à effectuer sur son application Metro avant toute soumission.

http://blogs.msdn.com/b/windowsappdev_fr/archive/2012/07/23/windows-8-metro-testing.aspx (français)

Enfin, notre Eric Vernié national décrit l'itinérance des paramètres d'une application Windows 8 (les Roaming Settings), limités à 100Ko pour mémoire.

http://blogs.msdn.com/b/devosaure/archive/2012/07/23/itinerance-des-param-232-tres-d-une-application-windows-8-au-style-metro.aspx

Bonne lecture

Tester votre application Metro pour Windows 8

Fri, 13 Jul 2012 07:38:36 GMT

Quand vous voulez diffuser une application Metro pour Windows 8, vous êtes obligé de passer par le Windows Store et donc, comme pour iPhone, Android, Windows Phone 7, passer par une approbation de votre application.

Ce processus de validation prend plus ou moins du temps (Microsoft annonce 6 jours pour Windows 8) donc il est important de bien valider votre application avant de l'envoyer dans le process. Si vous oubliez une chose, au bout de 6 jours on vous dit : hey, faudrait rajouter ca ! et c'est reparti pour 6 jours d'attente.

Donc il est important de lire l'article paru ce matin sur le blog des développeurs Windows 8 ou

J. Kalyana Sundaram, Senior SDET, Windows
Ashwin Needamangala, Principal Test Lead, Windows
Mete Goktepe, Principal Test Manager, Windows

(sont cosmopolites chez MS ;-)) décrivent complètement tous lles points importants de la validation (il faut impérativement supporter le mode Snap, tester dans différentes résolutions d'écran, etc.)

Bref, un article à lire : http://blogs.msdn.com/b/windowsappdev/archive/2012/07/12/testing-metro-style-apps-in-windows-8.aspx

(moi, je croise les doigts, ca fait 2 jours qeu mon appli est en cours de validation...)

Tout savoir sur les tuiles de Windows 8 (C#/XAML)

Wed, 11 Jul 2012 09:32:45 GMT

Un article très intéressant et très complet de Nathanael Marchand sur Developpez.com sur les tuiles (on dit pas plutôt vignettes ?) de Windows 8.

En voici le menu complet :

I. Avant-propos et introduction
I-A. Un mot sur l'auteur
I-B. Introduction
II. Premiers pas avec la tuile principale
II-A. Configurer sa tuile principale
II-B. Faire vivre sa tuile
II-B-1. Premier contact
II-B-2. Choisir son modèle
II-B-3. Annuler la notification
II-B-4. Expiration de l'information
II-B-5. File de notifications
II-B-6. Le Tag d'une notification
II-B-7. Le calendrier de notification
II-B-8. Les notifications distantes
II-B-9. Gérer les préférences de l'utilisateur
II-C. Du point de vue des « guidelines »
III. Aller plus loin avec les tuiles secondaires
III-A. Qu'est ce qu'une tuile secondaire ?
III-B. Comment créer une tuile secondaire ?
III-C. Animer les tuiles secondaires
III-D. Du point de vue des « guidelines »
IV. Les badges
IV-A. Kézako ?
IV-B. Créer un badge
IV-C. Les différents badges disponibles
IV-D. Du point de vue des « guidelines »
V. L'écran de verrouillage
V-A. Les applications et l'écran de verrouillage
V-B. Apparaître sur l'écran de verrouillage
VI. Conclusion

Bref, un article à lire (<mode lourd>même si on dit vignette et pas tuile</mode lourd>).

Comment utiliser DirectX avec C#/XAML pour Windows 8 Metro

Wed, 04 Jul 2012 15:00:23 GMT

On le sait, Microsoft a décidé d'arrêter XNA. Il y a cependant des moyens de contourner le problème en utilisant SharpDX comme je l'évoquait il y a quelques mois.

Notre David Catuhe national en a fait la démonstration lors du lancement de la communauté Windows 8.

Vous pouvez retrouver ses slides ici.

Reste maintenant à savoir si une appli utilisant une telle technologie passera le test du market...

6 choses à savoir sur le dev Windows 8

Thu, 31 May 2012 06:31:21 GMT

Julien Dollon (futur Microsoftee), vient de publier un billet sur le développement pour Windows 8 (bientôt, faudra qu'il fasse attention à ce qu'il publie s'il veut pas finir comme Chuck "Norris" Chan).

Il répond aux questions :

Le Xaml c'est du WPF like ? Comment C++ peut-il y accéder ?
Les langages se valent-ils ?
Avons-nous un full support de HTML5/CSS3/JS ?
.NET est-il mort ?
Win32 est-il mort ?
Puis-je utiliser Blend pour créer un site web HTML5/CSS3 ?

Windows 8 : Préparer la publication sur le Store

Tue, 29 May 2012 12:53:21 GMT

Stéphanie Hertrich de Microsoft France nous montre quels sont les points importants à vérifier avant de publier une application sur le Store de Windows 8 (ca devrait être possible que les jours qui viennent).

Un mémo important à lire pour éviter de passer du temps pour rien et de râler plus tard contre Microsoft (ca, c'est pour moi ;-)))

http://blogs.msdn.com/b/stephe/archive/2012/05/29/m-233-mo-win8-pr-233-parer-la-publication-sur-le-store.aspx

Quelques astuces pour améliorer les permorfances de vos applications Metro Xaml

Tue, 29 May 2012 05:58:47 GMT

Microsoft a publié la semaine dernière un livre blanc d'une trentaine de page sur l'amélioration des performances de vos applications Metro Xaml.

J'ai parcourru le document et il est vraiment très bien. On apprend plein de choses et je pense que tout développeur Windows 8 devrait avoir lu (ou au moins parcourru) ce document. Au menu :

Introduction
Remaining responsive
Ensuring fluid animations
Instantaneous activation
Optimizing app process lifetime
Gracefully loading, storing, and displaying data
Resource-friendly media
DirectX interop

Téléchargement du document Word ici.

Rester productif lorsque votre application n'est pas à l'écran : suite

Fri, 25 May 2012 05:59:52 GMT

Après Rester productif lorsque votre application n'est pas à l'écran, le blog des développeurs Windows 8 de Microsoft vient de publier un billet y faisant suite.

Il vous montre cette fois comment développer une tâche de fond qui s'exécute toutes les x minutes. Il explique surtout quels sont les limites, les ressources CPU accordées à votre tâche, le traffic réseau autorisé, etc.

Bref, un billet à lire comme d'habitude sur ce blog.

Rester productif lorsque votre application n'est pas à l'écran

Wed, 23 May 2012 06:12:07 GMT

Toujours dans le cadre de ses efforts de traduction de ses blogs importants, le blog des développeurs d'applications Windows 8 vient de publier un billet sur les possibilités qui s'offrent à vous d'effectuer des tâches en arrière plan.

On découvre ainsi cmment télécharger des fichiers, lire de l'audio, partager des données, synchroniser des appareils, notifier l'utilisateur, etc.

Il est important de bien maitriser tout ceci car Windows 8 optimise ses ressources (et donc la batterie de l'appareil). Ne pas en profiter serait une erreur : les applis non consommatrices de ressource seront toujours mieux appréciées ;-)

http://blogs.msdn.com/b/windowsappdev_fr/archive/2012/05/22/rester-productif-lorsque-votre-application-n-est-pas-224-l-233-cran.aspx

Création d'une application Metro de A à Z en une semaine par David Catuhe : J+4

Wed, 23 May 2012 05:54:32 GMT

Pour mémoire : David Catuhe a commencé l'écriture d'une série d'article montrant comment créer une application WinRT en Html5/Css3/Javascript de A à Z en moins d'une semaine.

J+0 : Après la mise en place du projet,
J+1 : comment gérer les paramètres de l'application et le mode déconnecté,
J+2 : la gestion des vues, l'internationalisation, la gestion des résolutions,
J+3 : Les contrats et les vignettes,

Cette fois, pour son dernier jour (oui, ils travaillent que 5 jours/semaine chez Microsoft), il aborde la sauvegarde de ses images sur Skydrive.

SQLite pour WinRT: c'est possible !

Mon, 21 May 2012 06:37:03 GMT

A l'heure d'aujourd'hui (21 Mai 2012), il n'y a pas, à ma connaissance, de version de SQL Server pour WinRT (Metro). Je pense que tout comme pour Windows Phone 7, cela va venir, mais il n'y a rien pour l'instant.

Sauf que ce 18 Mai dernier, lors de la conférence "Developing Windows 8 Metro style apps with C++", Richard Hipp, fondateur du projet SQLite en 2000, annonce que son moteur de base de données "light", SQLite, peut être compilé pour WinRT.

Pour savoir comment faire, je vous invite à suivre le billet de Tim Heuer.

Les Labs du Tour de France Windows 8 sont disponibles

Sun, 20 May 2012 13:02:54 GMT

Si vous n'avez pas pu suivre une des sessions du Tour de France Windows 8, les Labs (8 exercices) sont disponibles en téléchargements.

Ces Labs, pour Xaml/C# et Html5/js, font un tour complet des fonctionnalités d'une application typique pour WinRT. Donc très sympa à suivre ne serait-ce qu'une seule fois.

http://www.microsoft.com/en-us/download/details.aspx?id=29854 (300Mo quand même ;-))

Programming Windows 6ème édition de Charles Petzold en eBook

Fri, 18 May 2012 07:09:28 GMT

Charles Petzold après quelques hésitations vient de commencer la rédaction de la 6ème édition de son fameux Programming Windows.

De façon originale, il (avec son éditeur O'Reilly), a décidé de délivrer périodiquement des versions de son livre.

On a donc droit maintenant à la version Consumer Preview, un eBook de 294 pages. Cette version est à $10 seulement jusqu'au 31 Mai puis sera à $20 après.

Une version sur la release sera présenté ultérieurement (dates inconnues) à $30 puis $40 et enfin, la version finale ) $50 le 15 novembre prochain.

Donc $10 pendant les 15 prochains jours, c'est une bonne opportunité.

Comment redimensionner une image avec WinRT : plusieurs solutions

Fri, 11 May 2012 13:48:33 GMT

J'ai participé hier à une session du Tour de France Windows 8 à Bordeaux. Session très sympathique avec de charmants co-développeurs.

J'en ai profité pour m'avancer sur mon projet d'application WinRT et de me pencher plus avant sur la problématique suivante :

J'ai des nombreuses images dans mon application qui sont de taille "importante" (supérieure à 1024*768). Or il se trouve que ces images peuvent être utilisées pour la vignette de mon application. J'ai donc soit le choix de créer "à la main" une version light de mes images, soit ajouter la fonctionnalité à mon application de redimensionnement d'images (pour info, le poids des images affichées dans les vignettes est limitée, 150Ko je crois de mémoire).

La solution que j'ai trouvée était la suivante :

Une solution "pas simple"

La première étape consiste à récupérer la première frame de l'image à partir du fichier :

// imageFilename 
//      C'est le nom du fichier. 
//      Ici, c'est un fichier image que l'on a placé dans notre projet en tant que Contenu
//      (répertoire Assets dans le projet template de MS) 
//      Il se trouve donc dans le InstalledLocation
//      récupération du fichier, StorageFile
// fileName
//      nom du fichier que l'on veut sauvegarder
// width, height
//      largeur et hauteur de l'image finale désirée

var file = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(imageFilename);
// récupération du flux du fichier
var baseStream = RandomAccessStreamReference.CreateFromFile(file);
// décodeur de l'image à partir du flux ouvert en lecture
var fileDecoder = await Windows.Graphics.Imaging.BitmapDecoder.CreateAsync(await baseStream.OpenReadAsync());
// récupération de la première frame de l'image
var bitmapFrame = await fileDecoder.GetFrameAsync(0);

Ensuite, on récupère les pixels de notre image en spécifiant la taille de l'image finale :

// on veut une image de la taille width*height
var bitmapTransform = new BitmapTransform { ScaledWidth = width, ScaledHeight = height };
// récupération des pixels
var pixelDatas =
    await bitmapFrame.GetPixelDataAsync(
        bitmapFrame.BitmapPixelFormat,
        bitmapFrame.BitmapAlphaMode,
        bitmapTransform,
        ExifOrientationMode.IgnoreExifOrientation,
        ColorManagementMode.DoNotColorManage);

Enfin, on crée le fichier final et on écrit les pixels dedans :

// le fichier ou l'on souhaite enregistrer l'image redimensionnée.
// On la place dans le LocalFolder de l'application
var targetFile =
    await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFileAsync(
        fileName,
        CreationCollisionOption.ReplaceExisting)
        .AsTask<storagefile>();

// ouverture du flux pour écrire dans le fichier
using (var fileStream = await targetFile.OpenAsync(FileAccessMode.ReadWrite))
{
    // l'encodeur de notre nouveau fichier image
    var newBitmapEncoder = 
        await Windows.Graphics.Imaging.BitmapEncoder.CreateAsync(
            BitmapEncoder.JpegEncoderId, 
            fileStream);
    // on écrit les pixels dans notre nouveau fichier en respectant les infos d'origine (dpi, alpha, etc.)
    newBitmapEncoder.SetPixelData(
        bitmapFrame.BitmapPixelFormat, 
        bitmapFrame.BitmapAlphaMode, 
        bitmapTransform.ScaledWidth, 
        bitmapTransform.ScaledHeight, 
        bitmapFrame.DpiX, 
        bitmapFrame.DpiY, 
        pixelDatas.DetachPixelData());

    // on s'assure que l'on vide bien tout
    await newBitmapEncoder.FlushAsync();
    await fileStream.FlushAsync();
}

Ce n'est pas vraiment simple, mais ca marche.

Une solution plus simple

Montrant ce code à notre cher GO, aka Benoit Laut de Bewise, il me dit : "Mais non, espèce d'abruti, y'a beaucoup plus simple :!".

Bon, OK, il m'a pas dit ca comme ca exactement ;-). Je précise pour ceux qui comprendrait pas le second degré. Il m'a dit très gentillement qu'il pensait qu'il y avait plus simple, notamment avec les méthodes GetThumbnails du framework. Il a donc recherché et quelques temps plus tard, il m'a trouvé le code suivant :

var file = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(imageFilename);
// on veut une vignette de type image de largeur width et redimensionnée
var thumbnail = await file.GetThumbnailAsync(
    Windows.Storage.FileProperties.ThumbnailMode.PicturesView, 
    width, 
    Windows.Storage.FileProperties.ThumbnailOptions.ResizeThumbnail);

// on crée le fichier cible
var storageFile = await Windows.Storage.ApplicationData.Current.LocalFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting);
// ATTENTION : Ajoutez System.IO qui comprend ces méthodes d'extensions
// le flux ou l'on souhaite écrire
var writer = await storageFile.OpenStreamForWriteAsync(); 
var outputStream = writer.AsOutputStream();

// sauvegarde dans le flux de la vignette
await RandomAccessStream.CopyAndCloseAsync(thumbnail, outputStream);

Il y a quand même beaucoup moins de ligne de code, et ca à l'air plus simple.

MAIS

Car souvent avec moi, il y a un MAIS. J'ai donc voulu voir le résultat de ces deux possibilités. Concrètement, on obtient bien une vignette avec la taille désirée (dans le deuxième cas, on ne peut pas spécifier la largeur ET la hauteur, mais ce n'est pas grave dans notre cas). Les deux images sont bien générées :

J'ai bien mes patates redimensionnées et on peut constater que le temps d'exécution est sensiblement le même.

Mais concernant le poids des fichiers, ce n'est pas du tout la même histoire.

Le fichier d'origine fait 250Ko.
Le ficher avec la méthode complexe fait 36Ko
Le fichier avec la méthode simple fait 250Ko !!!

C'est bizarre (et si vous avez une explication, je suis preneur). Mais toujours est-il que je vas donc utiliser la méthode "complexe" dans mon application.

Conclusion

Tout comme dans le framework .NET "normal", pour faire une même opération, on a de multiples possibilités. Mais l'avantage avec le framework normal, c'est que grâce à des décompilateurs, on peut savoir pourquoi. Peux être que sur des images beaucoup plus lourde, la solution complexe est beaucoup plus rapide, peux être qu'avec la version finale, le poid de l'image finale sera optimisée.

Mais comme on n'a pas accès à des décompilateurs pour voir le code qui est réellement exécuté, on est encore dans le flou, et seul des tests permettent de savoir ce qu'il faut utiliser.