Devosaure

Création d’un package APPX Windows 8 via les APIs C++

EVBB — Fri, 26 Apr 2013 13:23:05 GMT

Dans mon précédant billet Déploiement d’une application Windows 8 (Interface Moderne) en entreprise, j’expliquais qu’il était possible de créer un Package de 3 manières différentes.

Via l’outil MAKEAPPX.EXE, via Visual Studio 2012, et enfin via des APIs C++.

Dans ce billet, je vais me concentrer sur la création d’un package avec les APIs C++ , afin de pouvoir “scripter” via des commandes Powershell (sans passer par des outils du Kit de développement Windows 8 donc), la création du package.

L’architecture de la solution se décline de la manière suivante :

Télécharger la solution

Une librairie C++/CLI (PowerShellAppxPackage), qui est une extension à Powershell une CmdLet que je nomme New-AppxPackage. Je ne rentre pas dans les détails de création d’une CmdLet ici, mais vous retrouverez les bases de création d’une CmdLet en C# en VB.NET ou en C++/CLI, sur mon article Développer une extension à Powershell.

#include "..\NativeAppxPackage\NativeAppxPackage.h"
#include <memory>
#include <msclr\marshal.h>

using namespace System;
using namespace System::Management::Automation;
using namespace System::Configuration::Install;
using namespace System::Configuration;
using namespace System::ComponentModel;
using namespace msclr::interop;
namespace PowerShellAppxPackage {
 [Cmdlet(VerbsCommon::New,"AppxPackage")]
 public ref class NewAppPackage :public PSCmdlet
 {
 public :
 NewAppPackage()
 {
 _native=new NativeAppxPackage();
 if (_native==nullptr)
 {
 CheckAndThrowError(S_FALSE,"Could not instanciate the NativeAppxPackage class",ErrorCategory::InvalidOperation,"0");
 }
 CheckAndThrowError(_native->ComInitialize(),"Could not instanciate COM",ErrorCategory::InvalidOperation,"1");
 }
 ~NewAppPackage()
 {
 if (_native!=nullptr)
 delete _native;
 }
 private :
 NativeAppxPackage* _native;
 void CheckAndThrowError(HRESULT hr,String^ error,ErrorCategory category, String^ errorId)
 {
 if (FAILED(hr))
 {


 System::Exception^ exception=gcnew System::Exception(error);

 ErrorRecord^ record=gcnew ErrorRecord(exception,errorId,category,nullptr);
 ThrowTerminatingError(record);
 }
 }
 protected : virtual void ProcessRecord() override
 {

 marshal_context ctx;
 AppxProfile appxProfile;
 appxProfile.OutPutAppxPackageFile= ctx.marshal_as<LPCWSTR>(_outPutAppxPackageFile);
 appxProfile.InputDirectory=ctx.marshal_as<LPCWSTR>(_inputDirectory);
 appxProfile.Hash=ctx.marshal_as<LPCWSTR>(_hash);

 CheckAndThrowError(_native->CreateAppxPackage(appxProfile),"Creating Package Failed!",ErrorCategory::NotSpecified,"2");
 WriteObject("Create package succeeded!");
 }
 private:
 String^ _hash;
 String^ _outPutAppxPackageFile;
 String^ _inputDirectory;


 public :

 [Parameter(Position=0)]
 property String^ Hash
 {
 String^ get() {return _hash;}
 void set (String^ value) { _hash=value;}
 }
 [Parameter(Position=1)]
 property String^ InputDirectory
 {
 String^ get() {return _inputDirectory;}
 void set (String^ value) { _inputDirectory=value;}
 }

 [Parameter(Position=2)]
 property String^ OutPutAppxPackageFile
 {
 String^ get() {return _outPutAppxPackageFile;}
 void set (String^ value) { _outPutAppxPackageFile=value;}
 }

 };
 [RunInstaller(true)]
 public ref class NewAppxPackageSnapIn : PSSnapIn
 {
 public :
 property String^ Name
 {
 virtual String^ get() override
 {
 return "PowershellAppxPackage";
 }
 }
 property String^ Vendor
 {
 virtual String^ get() override
 {
 return "Eric Verni";
 }
 }
 property String^ VendorResource
 {
 virtual String^ get() override
 {
 return "PowershellAppxPackage";
 }
 }
 property String^ Description
 {
 virtual String^ get() override
 {
 return "This CmdLet create an AppxPackage";
 }
 }
 property String^ DescriptionResource
 {
 virtual String^ get() override
 {
 return "Check my blog http:///blogs.msdn.com//b/devosaure";
 }
 }
 };
}

En résumé, notre code CmdLet, possède deux classes

L’une NewAppPackage, qui définie notre CmdLet. Elle dérive de PSCmdlet, et surcharge la méthode ProcessRecord qui sera appelée lors de l’exécution de la commande New-AppXPackage
De plus elle expose 3 paramètres

Hash pour l’algorithme de Hashage à utiliser
InputDirectory, qui sera le chemin d’accès aux fichiers de l’application à packager
OutPutAppxPackageFile, Nom du fichier Appx.

La seconde classe NewAppxPackageSnapin qui dérive de la classe PSSnapin, permettra d’enregistrer la commande. Cette classe expose entre autre la propriété Name qui est à utiliser lors de l’enregistrement du Snapin. (Dans notre exemple le nom c’est PowershellAppxPackage)

Une librairie .LIB en ISO C++ (NativeAppxPackage), qui utilise les APIs de création de package et qui sera liée statiquement à notre librairie Powershell.

Pour cette librairie, je suis partie de l’exemple How to create an app package, que j’ai légèrement modifié, pour parcourir de manière dynamique la liste des fichiers et des répertoires à incorporer dans le package.

En résumé, pour créer un package il faut :

- Créer une fabrique de package IAppxFactory

CComPtr<IAppxFactory> PackageFactory;
 hr=PackageFactory.CoCreateInstance(__uuidof(AppxFactory),
 nullptr,
 CLSCTX_INPROC_SERVER);

-Créer le PackageWriter via la fabrique

CComPtr<IAppxPackageWriter> PackageWriter;
 CComPtr<IStream> OutPutStream;
 APPX_PACKAGE_SETTINGS PackageSettings={0};
 hr=SHCreateStreamOnFileEx(
 appxprofile.OutPutAppxPackageFile,
 STGM_CREATE | STGM_WRITE | STGM_SHARE_EXCLUSIVE,
 0,
 TRUE,
 NULL,
 &OutPutStream);
 if (FAILED(hr))
 {
 return hr;
 }

 PackageSettings.hashMethod=HashMethod;
 PackageSettings.forceZip32=TRUE;
 hr = PackageFactory->CreatePackageWriter(
 OutPutStream,
 &PackageSettings,
 &PackageWriter);

- Enfin ajouter les fichiers au PackageWriter via la méthode AddPayloadFile

HRESULT hr=S_OK;
 FileInfo ManifestInfo;
 auto VectorFileInfo=_vectorfiles.get();
 std::for_each(VectorFileInfo->begin(),VectorFileInfo->end(),[&](FileInfo fileinfo)->HRESULT
 {
 if (fileinfo.IsManifest()==false)
 {
 HRESULT hr=S_OK;
 //TODO: quit the loop
 CComPtr<IStream> FileStream=nullptr;
 hr = SHCreateStreamOnFileEx(fileinfo.GetCurrentPath().c_str(),
 STGM_READ | STGM_SHARE_EXCLUSIVE,
 0,
 FALSE,
 NULL,
 &FileStream);
 if (FAILED(hr))
 {
 return hr;
 }
 //TODO: Get The Type of the file
 hr=packagewriter->AddPayloadFile(fileinfo.GetFileName().c_str(),
 L"Text/html",
 APPX_COMPRESSION_OPTION_NORMAL,
 FileStream);
 if (FAILED(hr))
 {
 return hr;
 }

 }
 else
 {
 ManifestInfo=fileinfo;
 }
 return hr;
 });



 CComPtr<IStream> manifestStream = nullptr;

 hr = SHCreateStreamOnFileEx(ManifestInfo.GetCurrentPath().c_str(),
 STGM_READ | STGM_SHARE_EXCLUSIVE,
 0,
 FALSE,
 NULL,
 &manifestStream);

 if (SUCCEEDED(hr))
 {
 hr = packagewriter->Close(manifestStream);
 }

 return hr;

Vous trouverez également dans la solution, une troisième librairie réservée aux tests (Cela permet d’éviter de repasser dans l’environnement Powershell pour tester la création du Package).

Une fois la solution compilée, il faut installer notre extension Powershell.

1. Lancez Powershell en mode Administrateur

2. Utilisez l’utilitaire INSTALLUTIL.EXE, pour inscrire l’extension. (se trouve dans les répertoires
C:\Windows\Microsoft.NET\Framework64\v4.0.30319 ou C:\Windows\Microsoft.NET\Framework\v4.0.30319)

PS: Installutil.exe PowerShellAppxPackage.dll

3. Ensuite il faut enregistrer le snapin contenu dans notre extension
PS: Add-PssnapIn PowershellAppxPackage

4. Il est possible de vérifier sa présence
PS: Get-PSSnapin

Name : PowershellAppxPackage
PSVersion : 3.0
Description : This CmdLet create an AppxPackage

5. D’invoquer notre extension avec les bons paramètres

PS: New-AppxPackage -Hash shA256 -OutPutAppxPackageFile c:\temp\TestDeploiement.appx -InputDirectory c:\temp\manuel

Create Package succeeded !

Note : C:\temp\manuel doit contenir une arborescence valide, comme je le précise dans mon précédant billet Déploiement d’une application Windows 8 (Interface Moderne) en entreprise

Télécharger la solution

Dans un prochain article nous détaillerons la manière de signer ce package à l’aide d’API.

Eric Vernié

Déploiement d’une application Windows 8 (Interface Moderne) en entreprise

EVBB — Fri, 19 Apr 2013 15:19:03 GMT

Table des matières

Etapes pour le déploiement d’une application.

Création d’un package.

Création du package : Utilisation de MAKEAPPX.EXE.

Signature du package : Utilisation de SIGNTOOL.EXE, MAKECERT.EXE et PVK2PFX.EXE.

Déploiement du package.

Installation du certificat : Utilisation de CERTUTIL.EXE.

Déploiement du package via script Powershell

Activation des appareils avec une clé de sideloading.

Conclusion.

Déploiement avec Windows Intune. (Future)

Déploiement avec SCCM 2012 SP1. (Future)

Ressources complémentaires :

Windows 8 est désormais disponible depuis quelques mois, et c’est vrai que nous avons concentré pas mal d’efforts sur les applications grand publique installables à partir du Windows Store. Dans cet article, nous souhaitons approfondir les différentes étapes à suivre pour déployer une application d’entreprise sans passer par le Windows Store. Bien que la majorité des détails illustrés ici ne sont pas nécessaire à connaitre pour pouvoir déployer une application Windows 8, il nous semblait judicieux de vous en donner la teneur, afin que vous soyez à même de mieux comprendre ce que des logiciels d’administration tels que Windows Intune, ou SCCM 2012, ont besoin comme ressources et informations pour déployer correctement une application Windows 8. Enfin, si vous utilisez d’autres solutions logicielles, vous pourrez utiliser le modèle de script Powershell décrit dans cet article pour déployer vos applications.

Etapes pour le déploiement d’une application.

Pour qu’un déploiement d’une application Windows 8 (Interface Moderne) se passe correctement, il faut suivre 3 étapes indispensables.

1. Créer un package qui contiendra les fichiers nécessaires au bon fonctionnement de l’application.

2. Signer ce package avec un certificat valide.

3. Préparer le poste cible, afin que l’application puisse se déployer correctement.

o Déployer le certificat

o Déployer une licence pour les applications ou clé de sideloading. Comme nous le verrons par la suite, selon les cas, il sera nécessaire ou pas d’acquérir cette clé de sideloading.

Note : Nous précisons interface moderne, par opposition à des applications Windows 8 de bureau, qui s’installent de manière traditionnelle et qui ne rentrent pas dans le cadre de cet article.

Création d’un package

Comme indiqué dans la documentation Packages et déploiement d’applications (applications du Windows Store), un package, est un conteneur ayant l’extension .appx, incluant les fichiers de l’application et les dépendances. Il est basé sur la norme OPC, norme utilisé entre autre par les applications Office. Pour notre compréhension, nous avons seulement besoin de retenir que ce package n’est ni plus ni moins qu’un fichier zippé.

Note : en le renommant avec extension .zip, vous avez accès directement à son contenu.

Pour créer un package, vous avez 3 solutions.

· En utilisant des APIS C++ dont vous trouverez la documentation ici.

· En utilisant directement Visual Studio 2012
http://msdn.microsoft.com/fr-fr/library/hh454036.aspx
http://msdn.microsoft.com/fr-fr/library/hh975357.aspx

· En utilisant des outils du Kit de développement Windows 8.

Note : Dans cet article nous détaillons les étapes nécessaires à la création et à la signature d’un package pour qu’il puisse s’installer correctement. Néanmoins, sachez qu’il n’est pas forcément nécessaire de le faire, car Visual Studio 2012 peut créer et signer ce package automatiquement.

Création du package : Utilisation de MAKEAPPX.EXE.

On considère que vous avez déjà créé et compilé l’application. Vous devez donc vous retrouver avec une arborescence comme sur la figure suivante :

Néanmoins dans cette arborescence, il manque un élément qui décrit l’identité de l’application, l’OS sur lequel tourne l’application, les ressources de l’application, les capacités de l’application, ainsi que les dépendances de l’application. Cet élément, est le fichier manifeste AppxManifest.xml qui est essentiel pour la création du package.

<?xml version="1.0" encoding="utf-8"?>
<Identity Name="b5c68d7e-ad25-40ea-b70e-667e7fb08c4d" Publisher="CN=ericv" Version="1.0.0.0" ProcessorArchitecture="neutral" />
<Properties>
<DisplayName>TestDeploiement</DisplayName>
<PublisherDisplayName>ericv</PublisherDisplayName>
<Logo>Assets\StoreLogo.png</Logo>
</Properties>
<Prerequisites>
<OSMinVersion>6.2.1</OSMinVersion>
<OSMaxVersionTested>6.2.1</OSMaxVersionTested>
</Prerequisites>
<Resources>
<Resource Language="EN-US" />
</Resources>
<Applications>
<Application Id="App" Executable="TestDeploiement.exe" EntryPoint="TestDeploiement.App">
<VisualElements DisplayName="TestDeploiement" Logo="Assets\Logo.png" SmallLogo="Assets\SmallLogo.png" Description="TestDeploiement" ForegroundText="light" BackgroundColor="#464646">
<DefaultTile ShowName="allLogos" />
<SplashScreen Image="Assets\SplashScreen.png" />
</VisualElements>
</Application>
</Applications>
<Capabilities>
<Capability Name="internetClient" />
</Capabilities>
<build:Metadata>
<build:Item Name="TargetFrameworkMoniker" Value=".NETCore,Version=v4.5" />
<build:Item Name="VisualStudio" Version="11.0" />
<build:Item Name="OperatingSystem" Version="6.2.9200.16384 (win8_rtm.120725-1247)" />
<build:Item Name="Microsoft.Build.AppxPackage.dll" Version="11.0.50727.1" />
<build:Item Name="Microsoft.Windows.UI.Xaml.Build.Tasks.dll" Version="11.0.50727.1" />
<build:Item Name="MakePri.exe" Version="6.2.9200.16384 (win8_rtm.120725-1247)" />
</build:Metadata>
</Package>

Remarque : Nous reviendrons plus tard sur la propriété de Publisher="CN=ericv", car elle aura son importance lors de la signature de l’application.

Vous pouvez construire manuellement ce fichier en suivant les instructions dans l’aide en ligne How to create a package manifest manually, néanmoins dans un 1^er temps il est plus judicieux de le récupérer à partir du répertoire \bin\release. En effet, après compilation de l’application, Visual Studio 2012 le génère automatiquement. Copiez-le alors dans l’arborescence de votre projet, comme indiqué sur la figure suivante :

Pour créer un package de l’application, il faut utiliser l’outil MAKEAPPX.EXE de la manière suivante :

& '..\Program Files (x86)\Windows Kits\8.0\bin\x86\makeappx.exe' pack /v /h SHA256 /d "C:\temp\manuel" /p TestDeploiement.appx

Remarque : Nous utilisons dans cet article, des scripts Powershell pour exécuter nos commandes.

pack : Permet de créer un package (par opposition à la commande unpack, qui permet de dé zipper)

/v : affiche les messages (verbose)

/h : Créé un fichier Block Map (AppxBlockMap.xml) qui contient un hash SHA256 de tous les fichiers contenus dans le répertoire. Le fait de hacher les fichiers, empêchera quiconque d’altérer le package. Ici nous utilisons SHA256, mais il possible d’utiliser d’autres algorithmes (SHA384, SHA512).
Note : Retenez bien l’algorithme de hachage que vous utilisez, car il faudra le reprendre pour le certificat, ainsi que pour la signature du package.

/d : Chemin d’accès l’arborescence des fichiers

/p : Non du fichier appx de destination.

Note : Pour de plus amples informations sur les paramètres et l’utilisation de MAKEAPPX, reportez-vous à l’aide en ligne: http://msdn.microsoft.com/en-us/library/windows/desktop/hh446767(v=vs.85).aspx

Le fichier TestDeploiement.appx, est créé et en le dé-zippant comme nous pouvons le voir sur la figure suivante :

MAKEAPPX a créé un fichier AppxBlockMap.xml qu’il a inclus dans le package. Ce fichier contient la liste des fichiers qui ont été hachés.

<BlockMap xmlns="http://schemas.microsoft.com/appx/2010/blockmap"
HashMethod="http://www.w3.org/2001/04/xmlenc#sha256">
<File Name="Assets\DarkGray.png" Size="560" LfhSize="49">
<Block Hash="U4fpsAY9b4tSDh0bv0V0bXG/CNdjhP6wqQBd5Qa/nUI="/>
</File>
<File Name="Assets\LightGray.png" Size="560" LfhSize="50">
<Block Hash="DV0Yg6Jx0cm9SpEe3WvEeOEpiKnTQPPNMdQ8rExT2cE="/>
</File>
<File Name="Assets\MediumGray.png" Size="561" LfhSize="51">
<Block Hash="C8gMoc/xDtxoIJOG04Vw/EcxxvqtugqB54lCl3vsUco="/>
</File>
<File Name="Assets\Logo.png" Size="801" LfhSize="45">
<Block Hash="VL6ArkjkJC1WFwJI5zD/rGCigo0HJgoEjirA/WI4YjQ="/>
</File>
<File Name="Assets\SmallLogo.png" Size="329" LfhSize="50">
<Block Hash="NoVfu8bClyI81EmmfQL5yXbdPkMsmQW0/8avjx7sR6k="/>
</File>
<File Name="Assets\SplashScreen.png" Size="2146" LfhSize="53">
<Block Hash="Hbz7CYy7sz2pSm9MKPLegtlySyhUtVmaefln93bw/jY="/>
</File>
<File Name="Assets\StoreLogo.png" Size="429" LfhSize="50">
<Block Hash="3IJfy5T/YdOzk2jCfTEb33RzDl6pJERy5b/lEaEiS0M="/>
</File>
<File Name="Common\StandardStyles.xaml" Size="119067" LfhSize="56">
<Block Hash="Q03txv1/VSMxbYtxUBObzX4ZBYb6zIAU1Cj8nCPvo7U=" Size="5206"/>
<Block Hash="91O3FnJf9yOWG5zuBHiJS/OewSKS80AAylVNBMWENbI=" Size="4383"/>
</File>
<File Name="App.xaml" Size="926" LfhSize="38">
<Block Hash="n+b5r2Rxv1vGwQ57fzziYTkGx9RhenbyCFAcrVFJMt8=" Size="370"/>
</File>
<File Name="GroupDetailPage.xaml" Size="7675" LfhSize="50">
<Block Hash="bhYCLR56sIQNyEv9K8BI3o/YK97VFVdMFxlRk1gb7Qc=" Size="1770"/>
</File>
<File Name="GroupedItemsPage.xaml" Size="9233" LfhSize="51">
<Block Hash="yO5Sa/SVI7Fqa9dgqDjkW2zy0JTNzaJJCiKURC/BPd8=" Size="1934"/>
</File>
<File Name="ItemDetailPage.xaml" Size="10986" LfhSize="49">
<Block Hash="z5U+e+hHIGqsBOyYlVvFYLrO+Nk5URj9Dbiyylxn6oo=" Size="2216"/>
</File>
<File Name="DataModel\SampleDataSource.cs" Size="30555" LfhSize="59">
<Block Hash="FtFQmlKIL4x+vTBuVUSBSAcZIlzs+bcgCBsDu9MjNiQ=" Size="3471"/>
</File>
<File Name="TestDeploiement.pdb" Size="118272" LfhSize="49">
<Block Hash="PQUVHs5sUJAUaw9cj290Zer4izUz7gZiM73Dwc9pieI=" Size="12884"/>
<Block Hash="1LzNNNR0EWMBPh4wLPD2371f5pHMDS9J70c/vO/ro6w=" Size="14084"/>
</File>
<File Name="TestDeploiement.exe" Size="52736" LfhSize="49">
<Block Hash="js9b7xhjwvJq7EnEoSDLHGVHes2Of+8NIVVlOFmsxvE=" Size="21944"/>
</File>
<File Name="resources.pri" Size="2608" LfhSize="43">
<Block Hash="H+N2TIRqlaCDzwWwmH/tYLu0nLQA201cAVsHvh0yOeQ=" Size="767"/>
</File>
<File Name="AppxManifest.xml" Size="2116" LfhSize="46">
<Block Hash="aZ6ujWLP7cPC5HIaRkITZYJRyGaHyFqslmlt/g72j7Y=" Size="970"/>
</File>
</BlockMap>

Signature du package : Utilisation de SIGNTOOL.EXE, MAKECERT.EXE et PVK2PFX.EXE

Une fois le package créé, il faut le signer, deux cas de figure s’offrent à vous :

· Vous n’avez pas de certificat valide, dans ce cas il faudra créer un certificat auto signé à des fins de tests.

· Vous avez un certificat valide d’entreprise, cas que nous traiterons par la suite, car il faudra alors modifier la propriété Publisher dans le fichier manifeste.

Pour notre démonstration à des fins de tests, nous allons créer un certificat auto-signé à l’aide de l’outil MAKECERT.EXE.

Note : Encore une fois cet outil n’est à utiliser qu’à des fins de tests, dans une organisation digne de confiance, il vous faudra impérativement utiliser un certificat valide et non auto-signé.

& '..\Program Files (x86)\Windows Kits\8.0\bin\x86\makecert.exe' -a SHA256 -n CN=ericv /r /sv testDeploiement.pvk /h 0 /eku "1.3.6.1.5.5.7.3.3" /e "05/17/2013" TestDeploiement.cer

MAKECERT demande un mot de passe afin de protéger efficacement la clé privée. Pour notre exemple nous choisirons "TestDeploiement!"

ré-utilisez le même mot de passe.

Plusieurs choses à noter :

· Il faut utiliser le même algorithme de hachage que celui utilisé pour la création du package /a SHA256

· Il faut utiliser le même nom de Publisher que celui indiqué dans le manifeste –n CN=ericv

· Pour le paramètre /eku, il faut utiliser au minimum la suite 1.3.6.1.5.5.7.3.3, qui indique que le certificat sera utilisé pour de la signature de code.

· Il faut définir une date de validité du certificat /e.
Pour ce dernier paramètre, évitez de mettre une date de validité trop longue.

Note : Pour plus d’informations sur MAKECERT reportez-vous à l’aide en ligne. http://msdn.microsoft.com/fr-fr/library/bfsktky3(v=VS.80).aspx et pour création d’un certificat auto signé c’est ici. http://msdn.microsoft.com/fr-fr/library/windows/desktop/jj835832(v=vs.85).aspx

Néanmoins, pour signer le package, le certificat seul ne suffit pas, il faut un fichier au format .pfx (Personal Information Exchange) qui contiendra les clés privée et publique. Pour créer ce fichier nous allons utiliser l’utilitaire PVK2PFX qui prend en entrée le fichier TestDeploiement.pvk et TestDeploiement.cer que nous venons de créer, en précisant le même mot de passe à l’aide du paramètre /pi, et en sortie le fichier TestDeploiement.pfx.

& '..\Program Files (x86)\Windows Kits\8.0\bin\x86\pvk2pfx.exe' /pvk TestDeploiement.pvk /pi TestDeploiement! /spc TestDeploiement.cer /pfx TestDeploiement.pfx

Enfin nous allons signer le package avec l’outil SIGNTOOL qui prend en entrée le fichier TestDeploiement.pfx.

& '..\Program Files (x86)\Windows Kits\8.0\bin\x86\signtool.exe' sign /a /v /fd SHA256 /f TestDeploiement.pfx /p TestDeploiement! TestDeploiement.appx

The following certificate was selected:

Issued to: ericv

Issued by: ericv

Expires: Fri May 17 00:00:00 2013

SHA1 hash: 2394E7E30496BB2C06FE2A1BAC3DF8DEDDB2CCF8

Done Adding Additional Store

Successfully signed: TestDeploiement.appx

Number of files successfully Signed: 1

Number of warnings: 0

Number of errors: 0

A noter, que nous utilisons une nouvelle fois le même algorithme de hachage SHA256, et que nous précisons encore une fois le mot de passe /p TestDeploiement!
D’autre part SIGNTOOL possède un autre paramètre /u (non utilisé ici), et qui permet de spécifier l’utilisation avancée de la clé (eku). Par défaut eku est à Signature du code (1.3.6.1.5.5.7.3.3), nous n’avons donc pas besoin de le préciser dans la commande.

Note : Si vous obtenez l’erreur suivante avec SIGNTOOL, vérifiez la date de validité de votre certificat.

signtool.exe : SignTool Error: No certificates were found that met all the given criteria.

Au caractère Ligne:8 : 1

+ & '..\Program Files (x86)\Windows Kits\8.0\bin\x86\signtool.exe' sign /a /v /fd ...

+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+ CategoryInfo : NotSpecified: (SignTool Error:...given criteria.:String) [], RemoteException

+ FullyQualifiedErrorId : NativeCommandError

Note : Pour de plus amples information sur SIGNTOOL, reportez-vous à la documentation en ligne.
http://msdn.microsoft.com/fr-fr/library/8s9b9yaz%28v=VS.80%29.aspx

SIGNTOOL a ajouté le fichier AppxSignature.p7x de signature numérique au package comme illustré sur la figure suivante :

Note : Pour en savoir plus sur le contenu du package signé vous pouvez consulter l’aide en ligne. http://msdn.microsoft.com/fr-fr/library/windows/apps/hh464929.aspx

Si vous avez déjà un certificat valide d’entreprise, il n’est bien évidement pas nécessaire de créer le certificat, et seule les étapes de création et de signature du package seront obligatoire. Mais vous devrez être attentif à bien indiquer dans le manifeste au niveau de la propriété Publisher, la bonne chaine de caractères.

Par exemple Publisher=OID.0.9.120.167788.100.1.1=2536363, CN=MASOCIETE, OU=MASOCIETE. (Cette chaine provient de votre certificat, ici elle est bidon)
Si tel n’est pas le cas, lors de la signature vous obtiendrez une erreur du type signtool error 0x8007000b

Note : ¨Pour déboguer cette erreur, il vous suffit d’aller voir dans le journal des évènements.
Journaux des applications et des services\Microsoft\Windows\AppxPackagingOM\
l’erreur qui est générée. Elle devrait vous donner la bonne chaine du Publisher.
En règle générale, SIGNTOOL, logue toutes ces erreurs dans ce journal. Pour de plus amples informations sur la manière de résoudre des problèmes, reportez-vous à la section How to troubleshoot app package signature errors

Remarque : Si vous ne souhaitez pas manipuler les outils du SDK pour créer et signer le package de l’application avec votre certificat d’entreprise, vous pouvez utiliser directement Visual Studio 2012 en lui précisant le certificat à utiliser.

1. En indiquant directement dans Visual Studio 2012, qu’il faut utiliser votre certificat.

2. Puis créer le package et la signature automatiquement

Déploiement du package

Il existe 3 manières de déployer une application Windows 8.

· Via script Powershell, comme nous le détaillerons ici

· Via Microsoft SCCM 2012 SP1

· Via Microsoft Windows Intune

Note : En fait, il existe d’autres méthodes de déploiement de package via l’outil de gestion et maintenance des images de déploiement, ou même via InstallShield, mais que nous n’aborderons pas dans cet article.

Installation du certificat : Utilisation de CERTUTIL.EXE

Avant de déployer notre package, il faut installer le certificat. Soit vous utilisez un certificat d’entreprise, dans ce cas-là, il y a de fortes chances pour qu’il soit déjà installé sur votre poste d’entreprise via des stratégies de groupe mis en place par votre IT interne, soit l’installer à l’aide de l’outil CERTUTIL.EXE.

certutil -addstore trustedpeople .\TestDeploiement.cer

trustedpeople "Personnes autorisées"
La signature correspond à la clé publiquet d
Le certificat "CN=ericv" a été ajouté au magasin.

CertUtil: -addstore La commande s’est terminée correctement.

Pour vérifier si le certificat est dans le bon magasin, lancez l’outil CERTMGR.EXE, choisissez le magasin Personnes autorisées, comme indiqué sur la figure suivante :

On voit bien ici que le certificat auto signé, délivré à ericv par ericv, sa date d’expiration et l’eku (Enhanced Key usage), qui est bien sur signature de code.

Note : Pour de plus amples informations sur les certificats, reportez-vous à l’aide en ligne http://technet.microsoft.com/en-us/library/cc700805.aspx

Déploiement du package via script Powershell

Pour déployer l’application, nous utiliserons la commande Powershell Add-AppxPackage

Add-AppxPackage .\TestDeploiement.appx

Le déploiement est réussi, mais la question essentielle qui se pose, est-ce que l’installation réussira sur toutes les configurations ?

Cela dépend de certains facteurs que nous allons détailler maintenant.

Dans notre cas de figure, nous sommes sur un poste du développeur, c’est-à-dire que Visual Studio 2012 est installé, et particularité, pour développer des applications Windows 8 (Interface Moderne), il demande une clé de licence développeur. Cette clé est obtenue en se connectant avec un Compte Microsoft. Comme illustré sur la figure suivante :

Clé de licence développeur renouvelable tous les mois.

Note : Le Compte Microsoft qui n’est ni plus ni moins qu’un LIVE ID, que nous mentionnons plus haut n’est pas le compte développeur qui est nécessaire pour le déploiement via le Windows Store. Ce Compte Microsoft, est uniquement nécessaire pour développer des applications Windows 8 avec Visual Studio 2012, mais n’est pas nécessaire pour le déploiement d’une application d’entreprise. Il n’est à utiliser qu’a des fins de tests.
Pour résumé. Le Compte Microsoft est nécessaire pour développer des applications Windows 8 Interface Moderne, le Compte Développeur est nécessaire pour pouvoir publier des applications dans le Windows Store.

Le déploiement de l’application aboutit car la commande Add-AppxPackage se base sur cette clé de licence développeur pour déployer l’application.
Si vous souhaitez tester votre déploiement sur d’autres postes qui ne possèderaient pas une licence développeur, vous pouvez à l’aide de la commande Show-WindowsDeveloperLicenseRegistration, en demander une et en entrant vos informations de compte Microsoft.

Remarque : Si vous avez créé le package avec Visual Studio 2012, comme nous l’avons déjà vu plus haut, Visual Studio créé également un script d’installation Powershell (Add-AppDevPackage.ps1) que vous pouvez utiliser pour tester le déploiement de l’application sur d’autres postes. Si la licence développeur n’existe pas sur le poste cible, il vous la demandera automatiquement. D’ailleurs, en analysant ce script vous retrouverez certaines étapes de cet article.

Le script Add-AppDevPackage.ps1 :

· Vérifie si le package est bien signé. (Get-AuthenticodeSignature)

· Test la présence du certificat dans le répertoire courant et vérifie son format, sa date d’expiration et la signature de code pour l’eku.

· Vérifie que le package a bien été signé avec ce certificat. (Get-PfxCertificate).

· Vérifie que le certificat développeur est bien présent (Get-WindowsDeveloperLicence), si non demande à l’utilisateur de l’obtenir (Show-windowsDeveloperLicenseRegistration)

· Enfin, installe le package (Add-appxPackage).

Il existe d’autres commandes powershell que vous pouvez utiliser, pour tester et débuguer le déploiement d’un package.
Get-AppxLastError pour obtenir la liste des erreurs lors du déploiement
Get-AppxLog, pour obtenir le log du déploiement d’un package
Remove-AppxPackage, pour désinstaller un package

Note : Vous pouvez utiliser l’outil powershell_ise.exe, éditeur de script PowerShell pour écrire, déboguer ou exécuter des commandes Powershell.

Cette clé de licence développeur est à utiliser lorsque vous souhaitez, non pas tester le déploiement, mais tester si l’application fonctionne correctement sur tous types de configurations. Elle fausse totalement le déploiement de l’application en entreprise, il est donc judicieux de s’assurer qu’elle ne soit plus présente sur les postes cibles.

Sur notre poste de développement, nous allons donc la retirer à l’aide de la commande Unregister-WindowsDeveloperLicense.

Notre poste se retrouve alors vierge de toute licence, néanmoins, il faut au préalable désinstaller l’ancienne installation de notre package, soit vous le faite manuellement, soit vous utilisez la commande suivante :

Get-AppxPackage -name b5c68d7e-ad25-40ea-b70e-667e7fb08c4d | Remove-AppxPackage

Ou le GUID correspond au nom de l’application que l’on retrouve dans le fichier manifeste à la propriété Identity
<Identity Name="b5c68d7e-ad25-40ea-b70e-667e7fb08c4d"…

Ensuite on relance le déploiement avec la commande Add-AppxPackage, qui réussit, car notre poste dispose des caractéristiques suivantes :

· C’est un poste Windows 8 Entreprise

· Il est inscrit dans le domaine de l’entreprise

· La stratégie de groupe Autoriser l’installation des applications approuvées, est activée, comme indiqué sur la figure suivante :

Ce dernier cas de figure est le plus simple, car le poste est inscrit et géré par l’entreprise. En effet, Windows 8 Entreprise inscrit dans un domaine, possède des fonctionnalités internes qui permettent de déployer les applications sans obtenir de clé de sideloading.

Activation des appareils avec une clé de sideloading
Mais quand est-il lorsque le poste n’est pas un inscrit dans un domaine et que nos appareils n’utilisent pas Windows 8 Entreprise ?

Si nous essayons de déployer notre package sur des appareils Windows RT, Windows 8 Pro, et Windows 8 Entreprise hors domaine, la commande Add-AppxPackage retournera une erreur.

Le message est explicite, il vous faut une licence valide, c’est-à-dire une clé de Sideloading pour activer vos appareils.

L’obtention d’une telle clé est hors scope, néanmoins, je vous encourage à télécharger le document Volume Licensing Guide for Windows 8 and Windows RT si vous souhaitez en savoir plus.
Pour obtenir des clés de SideLoading vous pouvez également allez à la section Product Activation Key Information

Une fois que vous avez en poche cette fameuse clé de sideloading, qui permet d’activer l’appareil et ceci pour toutes les applications Windows 8 (Interface Moderne) qui y seront déployées, il faut la déployer.

Pour c faire nous allons utiliser l’outil SLMGR.EXE

Une 1^ere fois avec le paramètre /ipk avec la clé elle-même.

slmgr /ipk <Clé de licence>

Une seconde fois avec le paramètre /ato et un numéro d’identification unique qui sera toujours le même afin d‘activer la licence.

slmgr /ato ec67814b-30e6-4a50-bf7b-d55daf729d1e

Ensuite, vous pouvez déployer l’application normalement.

Conclusion

Comme vous pouvez le constater, il est possible de déployer des applications Windows 8 sans passer par le Windows Store, il suffit alors de créer un script Powershell adéquate et l’utiliser avec vos propres méthodes de déploiements.

Néanmoins, Microsoft propose des logiciels d’administration, tels que Windows Intune, ou SCCM 2012 SP1, qui vous aiderons :

· A déployer facilement vos packages d’applications, qu’elle que soit leur méthode de création, que ce soit à l’aide d’outils du Kit de développement Windows 8 comme nous venons le voir, ou tout simplement à l’aide de Visual Studio 2012.

· A mettre à disposition aux utilisateurs les applications, via un Store privé d’entreprise.

En résumé, avant de déployer son application d’entreprise, il suffit de vérifier :

· Que le package est bien valide.

· Que le package est bien signé avec le bon certificat.

· Que le certificat est bien déployé sur les postes clients.

· Que vous avez besoin ou pas de clés de sideloading.

Dans un prochain article, nous reviendrons sur Windows Intune et sur SCCM 2012 SP1.

Eric Vernié

Ressources complémentaires :

Création de package http://msdn.microsoft.com/fr-fr/library/windows/apps/hh975356(v=vs.110).aspx

Signature d’un package : http://msdn.microsoft.com/fr-fr/library/windows/apps/br230260.aspx

Packages et déploiement d’application : http://msdn.microsoft.com/fr-fr/library/windows/apps/hh464929.aspx

Empaquetage de votre application du Windows Store à l'aide de Visual Studio 2012

http://msdn.microsoft.com/fr-fr/library/hh454036.aspx

Comment ajouter et supprimer des applications :

http://technet.microsoft.com/fr-fr/library/hh852635.aspx

How to troubleshoot app package signature errors : http://msdn.microsoft.com/en-gb/library/windows/apps/jj835836.aspx

Windows Intune : http://www.microsoft.com/fr-fr/windows/windowsintune/pc-management.aspx

Introduction au développement PowerShell, Part I. http://msdn.microsoft.com/fr-fr/visualc/bb906067.aspx

Volume Licensing Guide for Windows 8 and Windows RT,

Développer un composant WinRT en C++ : Part I

EVBB — Tue, 26 Mar 2013 13:13:26 GMT

Un composant WinRT, c'est un composant développé en C++, C# ou VB.NET et qui peut être ré-utilisé par une application Windows Store développée en Javascript, en C++, en VB.NET ou en C#.

Pourquoi développer un composant WinRT en C++ ?

Pour réutiliser de l'existant.
Vous avez depuis des années un composant, qui rempli sont rôle, que vous avez éprouvé, testé, et approuvé, pourquoi réinventer la roue ?
Pour palier à des manques
La plate-forme WinRT a été conçue, pour être la plus légère qui soit. Il est donc possible qu'un certain nombre de "fonctionnalités" soient manquantes.
Impossibilité technique, ou difficulté accrue dans un langage.
Si vous souhaitez manipuler des APIs du système qui sont difficile, voir même impossible à utiliser dans un langage.
Performance
Désormais, développer une application Windows 8, c'est cibler des "appareils" qui n'ont pas forcement le même niveau de performances, que votre PC de développement.
Pas de SSD, moins de RAM, un processeur différent que le core I7-3770 à 3.4 GHz, comme les processeurs ARM par exemple (même si les prochaines générations de Tegra et Snapdragon qui arrivent, vont relever la barre.)

Pour développer un Composant WinRT en C++, vous avez à votre disposition deux modèles.
Le modèle pur Windows Store, c'est à dire en utilisant l'extension C++/CX du langage C++ du compilateur, qui permet de manipuler les types WinRT de la manière la plus simple qui soit.

Pour en savoir plus sur le comment du pourquoi de C++/CX Inside the C++/CX Design

Ou le modèle Windows Runtime Library (WRL)

L’un ou l’autre des modèles permettent de facilement écrire du code pour le Windows Runtime, mais avec WRL vous avez un accès plus bas niveau pour consommer des composants COM.

D’ailleurs WRL étant inspiré par ATL il sera plus facile d’interagir entre les deux. Si vous souhaitez en savoir plus sur ce dernier je vous encourage à aller voir Windows Runtime C++ Template Library (WRL) sur MSDN.

Si vous préférez ne pas manipuler C++/CX pour des raisons qui vous incombe, un Modèle Visual Studio de création d’un composant WRL est à votre disposition ici : http://visualstudiogallery.msdn.microsoft.com/346e6fbc-6508-43c8-af7f-9a922bb57128

Dans ces différents billets, pour illustrer le développement d'un composant WinRT en C++, j'ai utilisé pour ma part les extensions C++/CX, en conjonction avec une API Win32 pure et dure assez méconnue, Extensible Storage Engine (cf. article Wikipédia http://en.wikipedia.org/wiki/Extensible_Storage_Engine)

J’ai choisi cette API Win32 de base de données, au départ pour un projet interne et pouvoir créer un cache interne, qui bénéficie de toute l’infrastructure d’une base de données ISAM. Avec des indexes primaires, sur plusieurs colonnes, des champs multi-valués etc..

Bien évidement, j’aurais pu utiliser SQLite qui est plus aboutit, mais comme ESE est disponible sur toutes les plate-formes (ARM, X86 et X64) c’était l’occasion de démontrer la manière de développer un composant WinRT compatible sur toutes ces plate-formes sans le moindre effort.

Note : Le composant est une ébauche, et loin d’être aboutit à ce stade, tout n’est pas encore implémenté. Je l’utilise essentiellement pour de la consultation. L’API ESE étant très vaste, cela prendra sans doute un certain temps.

Pour en savoir plus sur les APIs ESE (Jet Blue) (http://msdn.microsoft.com/en-US/library/windows/apps/br205753 )

Développer un composant WinRT, (non graphique je précise), impose un certain nombre de règles, que nous allons détailler tout au long de ces différents billets.

La frontière des langages (ABI)
Les types commun, le boxing
Les exceptions
Les performances (astuce) i.e. StringReference, ArrayReference
Asynchronisme
Levée d'évènement et synchronisation de thread
Ajouter de l’aide aux différentes APIs

Création d’un composant WinRT en C++/CX

Choisir le projet Visual C++ | Windows Store | Windows Runtime Component

Classe Activable

namespace WindowsRuntimeComponent2
{
     public ref class Class1 sealed
     {
     public:
         Class1();
     };
}

Le modèle crée une classe dite “Activable”:
1. C’est à dire que les autres langages, peuvent l’activer par leur opérateur new (ou ref new pour C++/CX).
2. Plus précisément, c’est une référence à une classe, préfixée par le mot clé ref class, qui indique au compilateur de créer toute la plomberie pour pouvoir l’activer.
  Ne pas oublier que le type ref class Class1, est une classe COM (Common Object Model) qui dérive de IInspectable, qui dérive elle même de IUnknown, mais que le compilateur nous cache.
3. Pour que notre classe Class1, soit ”Activable” par d’autres langages, il faut un mécanisme neutre d’activation. Il faut passer par le modèle Fabrique de classe (Class Factory).
  Cela tombe bien, car le compilateur, crée pour nous une autre classe (en règle générale il la nomme du style __Class1ActivationFactory , qui implémente la méthode CreateFactory () pour créer la fabrique et qui dérive de l’interface IActivationFactory qui possède une méthode ActivateInstance(), ceci afin que le Windows Runtime active notre classe.
4. Imaginons que nous instancions notre objet en C#
  WindowsRuntimeComponent1.Class1 c=new WindowsRuntimeComponent1.Class1
1. La classe est également marquée sealed (scellée), cela veut dire qu’il ne sera pas possible d’en hériter. Ce que l’on peut lire dans les différentes discutions, et ce qui me semble le plus pertinent, c’est pour éviter la tentation qu’un développeur en hérite dans un autre langage. En effet, à la différence de .NET ou l’on peut hériter d’une classe développée dans un langage, dans une classe développée avec un autre langage, il ne faut pas oublier que notre composant est développé en Natif donc avec une ABI différente de celle de .NET.
2. Lors de la compilation, un fichier avec une extension .winmd est généré (Format CLI d’ailleurs, donc lisible avec un outil comme ILASM) et qui décrit sous forme de meta-données ce que sait faire le composant afin que les autres langages puissent y avoir accès. Le faite d’exposer à l’extérieur de son espace binaire (ABI) des informations, telles que les méthodes, les propriétés etc.. impose un certain nombre de règles que nous décrirons dans un prochain billet.
3. Dernière petite chose, Si vous souhaitez changer l'espace de nom, il faut changer le nom du fichier winmd avec la même nomenclature que l’espace de nom.
  Par exemple si vous choisissez une espace de nom du type FRDPE.WINRT.ESE.
  namespace FRDPE { namespace WINRT { namespace ESE {
  ….
  }}}
  
  Il faut changer le nom du fichier winmd en FRDPE.WINRT.ESE, sinon vous obtiendrez l’erreur suivante :
  
  error APPX1706: The .winmd file 'WindowsRuntimeComponent2.winmd' contains type 'FRDPE.WINRT.ESE.__IJetBlueEnginePublicNonVirtuals' outside its root namespace 'WindowsRuntimeComponent2'. Make sure that all public types appear under a common root namespace that matches the output file name.
  
  Pour ce faire, Affichez les propriétés du projet | Linker | Windows Metadata
Dans la prochaine partie, nous détaillerons au travers de notre exemple
- La frontière des langages (ABI), c’est à dire ce que nous pouvons ou ne pouvons pas exposer aux autres langages.
- Les types commun, le boxing, comment transtyper des types
- Les exceptions
Eric Vernié

Contrôle Carrousel en XAML : de C# à C++/CX

EVBB — Mon, 25 Mar 2013 18:07:14 GMT

Dans ce billet nous nous sommes amusé à transposer de C# vers C++/CX le contrôle carrousel de Sébastien Pertus, qu’il décrit dans son excellent article Create a custom user control using Xaml and C# for Windows 8 comme il n’y a rien de nouveau dans l’algorithme, je ne vais pas détailler ce qui a déjà été fait.

En faite l’idée est tout simplement de montrer les différences entre les deux langages si l’envie vous prenez de développer en C++/CX et de voir qu’en fin de compte il n’y pas énormément de différence et que l’écriture est assez similaire.

Pour ma part, la méthode que j’ai utilisé, c’est de copier le code C# dans le projet C++/CX que j’ai ensuite transposé dans cette dernière syntaxe. Temps d’écriture 1 grosse journée

Vous trouverez le code source de cette exemple ici :

Petit Rappel :

Une application Windows 8 (Quel que soit le langage utilisé C++/CX,C#, VB ou Javascript) est basée sur un nouveau Jeu d’API native, le Windows Runtime connue sous le nom de WinRT.

C# est quant à lui basé sur une machine Virtuelle le CLR (Common Langage Runtime) qui fera le pont entre le monde .NET et le monde Natif, on appelle cela la projection.

Cette projection permet de mapper à peu près tous les types .NET vers la WinRT. Les primitives (String, int etc..), les interfaces, les enums, les structs, les delegates, , par exemple un IList<T> en .NET sera mappée en IVector<T> etc..

Cela veut dire comme nous le verrons plus tard, qu’il est possible d’utiliser directement des jeux d’API .NET dans son application sans se soucier s’il y a un pendant en WinRT (comme nous le verrons plus tard), il faudra donc le prendre en compte et trouver une correspondance en WinRT pour C++/CX.

Si la transposition n’est pas automatique, il est possible d’utiliser des méthodes d’extensions disponibles dans .NET pour explicitement utiliser ou convertir des types .NET vers des types WinRT.

Par exemple en incluant l’espace de nom System.Runtime.InteropServices.WindowsRuntime vous avez accès à la méthode d’extension .AsBuffer(), qui permet de convertir un tableau de byte[] en IBuffer<Byte>, interface utilisée massivement dans la WinRT.

Transposition du code C# vers du C++/CX

Le contrôle de Sébastien, permet d’afficher des images, qui pourront défiler à droite et à gauche avec la souris ou en tactile, avec une petite animation. Ces images seront liées via un pseudo modèle MVVM.

Notre première tâche est donc de construire le modèle MVVM pour C++/CX

C#
    public class MainPageViewModel
     {
         public ObservableCollection<Data> Datas { get; set; }
         public MainPageViewModel()
         {
             this.Datas = new ObservableCollection<Data>();
             this.Datas.Add(new Data { BitmapImage = new BitmapImage(new Uri("ms-appx:///Assets/pic01.jpg", UriKind.Absolute)), Title = "Wall 05" });
             this.Datas.Add(new Data { BitmapImage = new BitmapImage(new Uri("ms-appx:///Assets/pic02.jpg", UriKind.Absolute)), Title = "Wall 06" });
             this.Datas.Add(new Data { BitmapImage = new BitmapImage(new Uri("ms-appx:///Assets/pic03.jpg", UriKind.Absolute)), Title = "Wall 07" });
             this.Datas.Add(new Data { BitmapImage = new BitmapImage(new Uri("ms-appx:///Assets/pic04.jpg", UriKind.Absolute)), Title = "Wall 08" });
             this.Datas.Add(new Data { BitmapImage = new BitmapImage(new Uri("ms-appx:///Assets/pic05.jpg", UriKind.Absolute)), Title = "Wall 09" });
             this.Datas.Add(new Data { BitmapImage = new BitmapImage(new Uri("ms-appx:///Assets/pic06.jpg", UriKind.Absolute)), Title = "Wall 10" });
      
         
         }
     }
     public class Data
     {
         public BitmapImage BitmapImage { get; set; }
         public String Title { get; set; }
     }
 }

C++/CX
namespace YellowStone
 {
     [Windows::UI::Xaml::Data::Bindable]
     public ref class Data sealed
     {
     public :
         Data(Windows::UI::Xaml::Media::Imaging::BitmapImage^ bmp,Platform::String^ title);
 
         property Windows::UI::Xaml::Media::Imaging::BitmapImage^ BmpImage;
         property Platform::String^ Title;
     };
     
     [Windows::UI::Xaml::Data::Bindable]
     public ref class MainPageViewModel sealed
     {
              
     public:    
         MainPageViewModel(void);
         virtual ~MainPageViewModel(void);
         
         //Expose only public Type through ABI
         property Windows::Foundation::Collections::IObservableVector<Object^>^  Datas;
     };    
 }

Tout d’abord une classe C++/CX doit être notée avec l’attribut Windows::UI::Xaml::Data::Bindable afin que le type soit inclu dans le fichier XAML généré. (cela suffit pour que cela fonctionne dans notre exemple mais pour aller plus loin vous devriez également implémenter l’interface INotifyPropertyChanged cf l’article MVVM in C++/CX )

Vous noterez que dans le code C#, il utilise une liste .NET ObservableCollection<Data> pour la propriété Datas, alors que nous utilisons l’interface WinRT Windows::Foundation::Collections::IObservableVector<Object^> en lui passant un Object^ plutôt qu’un type Data^. Si nous avions utilisé le type Data^ nous aurions eu une erreur de transtypage à l’exécution lors du binding, alors que la projection de C# fait le transtypage pour nous.
Vous noterez également que nous pouvons utiliser une syntaxe simplifiée en C++/CX comme en C# pour la déclaration de la propriété.

Propriété en C++/CX
property int Depth { 
             int get() {return static_cast<int>(DependencyObject::GetValue(DepthProperty));}
             void set (int value){DependencyObject::SetValue(DepthProperty,value);}
             }

Pour instancier la liste Datas (IObservableVector<T>) nous utiliserons le type natif à la WinRT Platform::Collections::Vector<Object^>, comme dans le code suivant du constructeur de la classe MainPageViewModel.

C++/CX

 MainPageViewModel::MainPageViewModel(void)
 {
     this->Datas=ref new Platform::Collections::Vector<Object^>();
       BitmapImage bmp1(ref newUri("ms-appx:///Assets/pic01.jpg"));
     auto data1=ref new Data(%bmp1,"Wall 05");
     
       BitmapImage bmp2(ref newUri("ms-appx:///Assets/pic02.jpg"));
     auto data2=ref new Data(%bmp2,"Wall 06");
 
       BitmapImage bmp3(ref newUri("ms-appx:///Assets/pic03.jpg"));
     auto data3=ref new Data(%bmp3,"Wall 07");
 
       BitmapImage bmp4(ref newUri("ms-appx:///Assets/pic04.jpg"));
     auto data4=ref new Data(%bmp4,"Wall 08");
 
       BitmapImage bmp5(ref newUri("ms-appx:///Assets/pic05.jpg"));
     auto data5=ref new Data(%bmp5,"Wall 09");
 
       BitmapImage bmp6(ref newUri("ms-appx:///Assets/pic06.jpg"));
     auto data6=ref new Data(%bmp6,"Wall 10");
 
     
     this->Datas->Append(data1);    
     this->Datas->Append(data2);
     this->Datas->Append(data3);
     this->Datas->Append(data4);
     this->Datas->Append(data5);

Remarque : Pourquoi ne pas utiliser dans la déclaration de la propriété Datas directement le type Platform::Collections::Vector<Object^> ?
C’est très simple, parce que cette propriété est déclarée publique, et qu’il n’est pas possible d’émettre dans le fichier winmd des types autres que des types WinRT (c’est à dire visible dans les autres langages)

Plusieurs chose à noter par rapport au code C#.

C++/CX utilise la notion de référence symbolisée par le caractère ^, pour initialiser une référence on utilise ref new pour l’instanciation de la classe alors que C# utilise une référence implicite instanciée par le mot clé new
T^ t=ref new T();
L’opérateur de portée pour une référence est la flèche –> alors qu’en C# c’est le point. Jusqu’ici rien de bien trop compliqué.
t->MethodA();
Néanmoins, C++/CX, permet également comme dans du code ISO C++ traditionnel, d’avoir une initialisation sur la pile. C’est à dire que la référence à l’objet disparait lorsque la méthode se termine. (pas besoin alors de faire de delete)
T t;
L’opérateur de portée devient le point.
t.MethodA();
Du coup pour déférencer une référence on utilise l’opérateur %.
Au même titre que le mot clé var en C#, on utilise le mot clé auto pour simplifier et clarifier la syntaxe. le résultat est le même dans les deux langages, les compilateurs font de l’inférence de type.
Anecdotique, mais je le signale quand même, la liste Vector<T>, ne possède pas les mêmes méthodes que la liste .NET ObservableCollection<T>.
Pour ajouter un élément il faut utiliser la méthode Append() et pas la méthode Add(), pour compter les éléments il faut utiliser la propriété Size plutot que Count, etc…

Une fois le modèle défini, nous allons nous attaquer au contrôle proprement dit.

Un contrôle XAML, expose pour le DataBinding des DependencyProperty, en C# une syntaxe simplifiée est d’utiliser un champ publique statique associée à une propriété classique.

C#
/// <summary>
       /// Items source : Better if ObservableCollection :)
       /// </summary>
       public IEnumerable<Object> ItemsSource
       {
           get { return (IEnumerable<Object>)GetValue(ItemsSourceProperty); }
           set { SetValue(ItemsSourceProperty, value); }
       }
 
       // Using a DependencyProperty as the backing store for ItemsSource.  
       //This enables animation, styling, binding, etc...
       public static readonly DependencyProperty ItemsSourceProperty =
           DependencyProperty.Register("ItemsSource",
                       typeof(IEnumerable<Object>),
                       typeof(LightStone),
                       new PropertyMetadata(0, ItemsSourceChangedCallback));

C#
private static void ItemsSourceChangedCallback(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs args)
  {
      
      if (args.NewValue == null)
          return;
 
      if (args.NewValue == args.OldValue)
          return;
 
      LightStone lightStone = dependencyObject as LightStone;
 
      if (lightStone == null)
          return;
 
      var obsList = args.NewValue as INotifyCollectionChanged;
 
      if (obsList != null)
      {
          obsList.CollectionChanged += (sender, eventArgs) =>
              {
                  switch (eventArgs.Action)
                  {
                      case NotifyCollectionChangedAction.Remove:
                          foreach (var oldItem in eventArgs.OldItems)
                          {
                              for (int i = 0; i < lightStone.internalList.Count; i++)
                              {
                                  var fxElement = lightStone.internalList[i] as FrameworkElement;
                                  if (fxElement == null || fxElement.DataContext != oldItem) continue;
                                  lightStone.RemoveAt(i);
                              }
                          }
 
                          break;
                      case NotifyCollectionChangedAction.Add:
                          foreach (var newItem in eventArgs.NewItems)
                              lightStone.CreateItem(newItem, 0);
                          break;
                  }
              };
      }
 
      lightStone.Bind();
  }

En C++, cela ce fait en 2 temps. Tout d’abord dans le fichier d’entête on déclare la propriété statique ItemsSourceProperty, la propriété qui invoquera la DependencyProperty et la méthode statique qui sera invoquée

C++/CX
static property Windows::UI::Xaml::DependencyProperty^ ItemsSourceProperty
         {
             Windows::UI::Xaml::DependencyProperty^ get();
         }
         property Windows::Foundation::Collections::IObservableVector<Object^>^ ItemsSource {
             Windows::Foundation::Collections::IObservableVector<Object^>^ get(){ 
                 return safe_cast<Windows::Foundation::Collections::IObservableVector<Object^>^>(DependencyObject::GetValue(ItemsSourceProperty));}
             void set (Windows::Foundation::Collections::IObservableVector<Object^>^ value)
             {
                 DependencyObject::SetValue(ItemsSourceProperty,value);
             }
         }

C++/CX
 static void OnItemsSourcePropertyChanged(Windows::UI::Xaml::DependencyObject^ d, Windows::UI::Xaml::DependencyPropertyChangedEventArgs^ e);
 

Puis dans le fichier CPP on déclare le champ statique qui sera exposé à l’extérieure par l’intermédiaire de la propriété ItemsSourceProperty, et on implémente la méthode get de la propriété et la méthode statique de rappel.

C++/CX
static DependencyProperty^ m_ItemsSourceProperty=
             DependencyProperty::Register("ItemsSource",TypeName(Object::typeid),TypeName(Carroussel::typeid),
         ref new PropertyMetadata(nullptr, ref new PropertyChangedCallback(
         &Carroussel::OnItemsSourcePropertyChanged)));
 DependencyProperty^ Carroussel::ItemsSourceProperty::get()
 {
     return m_ItemsSourceProperty;
 }
 void Carroussel::OnItemsSourcePropertyChanged(DependencyObject^ d, DependencyPropertyChangedEventArgs^ e)
 {
     
     if (e->NewValue == nullptr)   return;
 
     if (e->NewValue == e->OldValue)  return;
 
      auto target = dynamic_cast<Carroussel^>(d);
     
     if (target == nullptr)  return;
     IObservableVector<Object^>^ source=dynamic_cast<IObservableVector<Object^>^>(e->NewValue);
     if (source==nullptr)
         return;
     target->ItemsSource=source;
     target->ItemsSource->VectorChanged+=ref new VectorChangedEventHandler<Object^>([target,source](Object^sender, IVectorChangedEventArgs^e)
     {
         auto action=e->CollectionChange; 
         auto index=e->Index;
         if (action==CollectionChange::ItemInserted)
         {
             target->CreateItem(source->GetAt(index),0.0);
         }
         else
         {
         }
     });    
     target->Bind(source);        
 }

Plusieurs choses à noter par rapport au code C#

Pour obtenir le type pour le paramètre TypeName, on utilise le mot clé typeid. (N’apparait pas avec IntelliSense). TypeName(Object::typeid)
La syntaxe de la méthode statique de callback ne s’invente pas elle est issue de la normalisation C++, il faut la préfixer par & suivie du nom la classe puis du nom de la méthode. &Carroussel::OnItemsSourcePropertyChanged
En C++ on n’utilise plus l’opérateur (T) pour caster (même si on peut toujours le faire), mais les opérateurs, static_cast<T>, safe_cast<T> et dynamic_cast<T> à la place.
Par exemple dynamic_cast<T> correspond à l’opérateur as de C# : auto target = dynamic_cast<Carroussel^>(d)
Pour tester si un type est nul, l’opérateur nullptr est désormais disponible. if (target==nullptr)
En C# on utilise un ObservableCollection<T>, qui implémente l’interface INotifyCollectionChange et son évènement CollectionChanged , en C++/CX, on utilise la collection Platform::Collection::Vector<T> qui implémente l’interface IObservableVector et sont évènement VectorChanged
Il est possible d’utiliser des lambdas (depuis C++11), avec une syntaxe qui diffère de celle de C#
Comme on peut le voir ici, une lambda C++ se construit comme suit : [](){}; comme dans l’exemple ci-dessus alors qu’en C# c’est plutôt ()=>{};
Vous noterez qu’entre crochet, j’utilise les variables target et source, qui sont passées par valeur au corps de la lambda (le compilateur en fait une copie).
Pour récupérer un élèment de la liste source, on utilise pas un indexer mais directement la méthode source->GetAt(index).

Une méthode qui mérite notre attention car il y à des différences c’est ArrangeOverride, mais en les comparants vous vous apercevrez qu’en faite il n’y pas beaucoup de différence dans l'a syntaxe.

C#
protected override Size ArrangeOverride(Size finalSize)
     {
         if (isUpdatingPosition)
             return finalSize;
 
         Double centerLeft = 0;
         Double centerTop = 0;
         this.Clip = new RectangleGeometry { Rect = new Rect(0, 0, finalSize.Width, finalSize.Height) };
         // Set 
         Canvas.SetZIndex(rectangle, 1);
         // Storyboard for all Items to appear
         var localStoryboard = new Storyboard();
 
         for (int i = 0; i < this.internalList.Count; i++)
         {
             UIElement container = internalList[i];
             Size desiredSize = container.DesiredSize;
             
             if (double.IsNaN(desiredSize.Width) || double.IsNaN(desiredSize.Height)) continue;
 
             // get the good center and top position
             if (centerLeft == 0 && centerTop == 0 && desiredSize.Width > 0 && desiredSize.Height > 0)
             {
                 desiredWidth = desiredSize.Width;
                 desiredHeight = desiredSize.Height;
 
                 centerLeft = (finalSize.Width / 2) - (desiredWidth / 2);
                 centerTop = (finalSize.Height - desiredHeight) / 2;
             }
 
             // Get position from SelectedIndex
             var deltaFromSelectedIndex = Math.Abs(this.SelectedIndex - i);
 
             // Get rect position
             var rect = new Rect(centerLeft, centerTop, desiredWidth, desiredHeight);
 
             container.Arrange(rect);
             Canvas.SetLeft(container, centerLeft);
             Canvas.SetTop(container, centerTop);
 
             // Apply Transform
             PlaneProjection planeProjection = container.Projection as PlaneProjection;
 
             if (planeProjection == null)
                 continue;
 
             // Get properies 
             var depth = (i == this.SelectedIndex) ? 0 : -(this.Depth);
             var rotation = (i == this.SelectedIndex) ? 0 : ((i < this.SelectedIndex) ? Rotation : -(Rotation));
             var translateX = (i == this.SelectedIndex) ? 0 : ((i < this.SelectedIndex) ? -TranslateX : TranslateX);
             var offsetX = (i == this.SelectedIndex) ? 0 : (i - this.SelectedIndex) * desiredWidth;
             var translateY = TranslateY;
 
             // CenterOfRotationX
             // to Get good center of rotation for SelectedIndex, must know the animation behavior
             int centerOfRotationSelectedIndex = isIncrementing ? 1 : 0;
             var centerOfRotationX = (i == this.SelectedIndex) ? centerOfRotationSelectedIndex : ((i > this.SelectedIndex) ? 1 : 0);
            
             // Apply on current item
             planeProjection.CenterOfRotationX = centerOfRotationX;
             planeProjection.GlobalOffsetY = translateY;
             planeProjection.GlobalOffsetZ = depth;
             planeProjection.GlobalOffsetX = translateX;
             planeProjection.RotationY = rotation;
             planeProjection.LocalOffsetX = offsetX;
 
             // calculate zindex and opacity
             int zindex = (this.internalList.Count * 100) - deltaFromSelectedIndex;
             double opacity = 1d - (Math.Abs((Double)(i - this.SelectedIndex) / (MaxVisibleItems + 1)));
 
             // Items appears
             if (container.Visibility == Visibility.Visible && container.Opacity == 0d)
             {
                 localStoryboard.AddAnimation(container, TransitionDuration, rotation, "(UIElement.Projection).(PlaneProjection.RotationY)", this.EasingFunction);
                 localStoryboard.AddAnimation(container, TransitionDuration, depth, "(UIElement.Projection).(PlaneProjection.GlobalOffsetZ)", this.EasingFunction);
                 localStoryboard.AddAnimation(container, TransitionDuration, translateX, "(UIElement.Projection).(PlaneProjection.GlobalOffsetX)", this.EasingFunction);
                 localStoryboard.AddAnimation(container, TransitionDuration, offsetX, "(UIElement.Projection).(PlaneProjection.LocalOffsetX)", this.EasingFunction);
                 localStoryboard.AddAnimation(container, TransitionDuration, translateY, "(UIElement.Projection).(PlaneProjection.GlobalOffsetY)", this.EasingFunction);
                 localStoryboard.AddAnimation(container, TransitionDuration, 0, opacity, "Opacity", this.EasingFunction);
             }
             else
             {
 
                 container.Opacity = opacity;
             }
 
             Canvas.SetZIndex(container, zindex);
 
         }
 
         rectangle.Fill = new SolidColorBrush(Colors.Black);
         rectangle.Opacity = 0.9;
         Canvas.SetLeft(rectangle, 0);
         Canvas.SetTop(rectangle, (this.ActualHeight / 2));
         Canvas.SetZIndex(rectangle, 1);
         rectangle.Width = this.ActualWidth;
         rectangle.Height = this.ActualHeight;
 
         if (localStoryboard.Children.Count > 0)
             localStoryboard.Begin();
 
         return finalSize;
     }

C++/CX
Size Carroussel::ArrangeOverride(Size finalSize)
 {
         if (isUpdatingPosition)
                 return finalSize;
 
             float centerLeft = 0;
             float centerTop = 0;
             RectangleGeometry rectGeo;
             Rect rect(0,0,finalSize.Width,finalSize.Height);
             rectGeo.Rect=rect;
             this->Clip=%rectGeo;
 
             // Set 
             Canvas::SetZIndex(rectangle, 1);
             
             // Storyboard for all Items to appear
             auto localStoryboard =ref new Storyboard();
             unsigned int count=this->internalList->Size;
             for (int i = 0; i < count; i++)
             {
                 UIElement^ container = internalList->GetAt(i);
                 Size desiredSize = container->DesiredSize;
                                                                 
                 if (_isnan(desiredSize.Width) || _isnan(desiredSize.Height)) continue;
 
                 // get the good center and top position
                 if (centerLeft == 0 && centerTop == 0 && desiredSize.Width > 0 && desiredSize.Height > 0)
                 {
                     desiredWidth = desiredSize.Width;
                     desiredHeight = desiredSize.Height;
 
                     centerLeft = (finalSize.Width / 2) - (desiredWidth / 2);
                     centerTop = (finalSize.Height - desiredHeight) / 2;
                 }
 
                 // Get position from SelectedIndex
                 int currentSelectedIndex=this->SelectedIndex;
                 auto deltaFromSelectedIndex = ::abs(static_cast<int>(currentSelectedIndex - i));
                 
                 // Get rect position
                 Rect rect(centerLeft, centerTop, desiredWidth, desiredHeight);
 
                 container->Arrange(rect);
                 Canvas::SetLeft(container, centerLeft);
                 Canvas::SetTop(container, centerTop);
 
                 // Apply Transform
                 PlaneProjection^ planeProjection = dynamic_cast<PlaneProjection^>(container->Projection);
 
                 if (planeProjection == nullptr)
                     continue;
 
                 // Get properies 
                 
                 auto depth = (i == currentSelectedIndex) ? 0 : -(this->Depth);
                 double currentRotation=this->Rotation;
                 int currentTranslateX=this->TranslateX;
 
                 auto rotation = (i == currentSelectedIndex) ? 0 : ((i < currentSelectedIndex) ? currentRotation : -(currentRotation));
                 auto translateX = (i == currentSelectedIndex) ? 0 : ((i < currentSelectedIndex) ? -currentTranslateX : currentTranslateX);
                 auto offsetX = (i == currentSelectedIndex) ? 0 : (i - currentSelectedIndex) * desiredWidth;
                 auto translateY =this->TranslateY;
 
                 // CenterOfRotationX
                 // to Get good center of rotation for SelectedIndex, must know the animation behavior
                 int centerOfRotationSelectedIndex = isIncrementing ? 1 : 0;
                 auto centerOfRotationX = (i == currentSelectedIndex) ? centerOfRotationSelectedIndex : ((i > currentSelectedIndex) ? 1 : 0);
                
                 // Apply on current item
                 planeProjection->CenterOfRotationX = centerOfRotationX;
                 planeProjection->GlobalOffsetY = translateY;
                 planeProjection->GlobalOffsetZ = depth;
                 planeProjection->GlobalOffsetX = translateX;
                 planeProjection->RotationY = rotation;
                 planeProjection->LocalOffsetX = offsetX;
 
                 // calculate zindex and opacity
                 int zindex = (count * 100) - deltaFromSelectedIndex;
                 
                 auto currentMaxVisibleItems=this->MaxVisibleItems;
                 double opacity=0.0;
                 opacity = 1.0 - (::abs(static_cast<double>((i - currentSelectedIndex))/ (currentMaxVisibleItems + 1)));
                 
                 auto currentEasing=this->EasingFunction;
                 
                 // Items appears
                 if (container->Visibility == Windows::UI::Xaml::Visibility::Visible && container->Opacity == 0.0)
                 {
                     this->AddAnimation(localStoryboard,container, TransitionDuration, rotation, "(UIElement.Projection).(PlaneProjection.RotationY)", currentEasing);
                     this->AddAnimation(localStoryboard,container, TransitionDuration, depth, "(UIElement.Projection).(PlaneProjection.GlobalOffsetZ)", currentEasing);
                     this->AddAnimation(localStoryboard,container, TransitionDuration, translateX, "(UIElement.Projection).(PlaneProjection.GlobalOffsetX)", currentEasing);
                     this->AddAnimation(localStoryboard,container, TransitionDuration, offsetX, "(UIElement.Projection).(PlaneProjection.LocalOffsetX)", currentEasing);
                     this->AddAnimation(localStoryboard,container, TransitionDuration, translateY, "(UIElement.Projection).(PlaneProjection.GlobalOffsetY)", currentEasing);
                     this->AddAnimation(localStoryboard,container, TransitionDuration, 0, opacity, "Opacity", currentEasing);
                 }
                 else
                 {
 
                     container->Opacity = opacity;
                 }
 
                 Canvas::SetZIndex(container, zindex);
 
             }
             Color color;
             color.R=0;
             color.B=0;
             color.G=0;
             rectangle->Fill = ref new SolidColorBrush(color);
             rectangle->Opacity = 0.9;
             Canvas::SetLeft(rectangle, 0);
             Canvas::SetTop(rectangle, (this->ActualHeight / 2));
             Canvas::SetZIndex(rectangle, 1);
             
             rectangle->Width = this->ActualWidth;
             rectangle->Height = this->ActualHeight;
 
             if (localStoryboard->Children->Size > 0)
                 localStoryboard->Begin();
             return finalSize;
 }

Tout d’abord comme en C# on utilise des objets XAML pure WinRT (Espace de nom Windows), on les utilise de la même manière en C# et en C++/CX.

Par exemple l’objet RectangleGeometry que j’utilise ici avec une syntaxe sur la pile (sans ref new) est passé à la propriété Clip avec l’opérateur de déférencement % c’est la seule différence avec C#, si j’avais utilisé une référence à la place RectangleGeometry^ rectGeo=ref new RectangleGeometry(), j’aurais directement utilisé l’affectation this->Clip=rectGeo;

En C# pour récupérer la valeur absolue, on utilise la méthode Math.Abs, qui est une classe pure .NEt et non pas WinRT, en C++/CX, comme nous pouvons mixer du code ISO C++ avec du code C++/CX, j’ai utilisé la méthode abs() de la runtime C.

Dans tous les cas, si il n’y pas de correspondance .NET <–> WinRT, il est possible d’utiliser d’autres librairies C ou C++. Par exemple, un Double en C# qui est un type (ValueType) possède une méthode IsNaN. Pas en C++/CX, ou il est possible d’utiliser la runtime C _isnan(double x);

Vous trouverez le code source de cette exemple ici :

Pour aller plus loin avec C++/CX je vous conseille fortement la lecture de Developing an end-to-end Windows Store app using C++ and XAML:hilo

Tips & Tricks : Modèle TAP (Task Asynchronous Pattern, i.e async/await) avec la classe WebClient de Windows Phone 8

EVBB — Tue, 06 Nov 2012 12:58:16 GMT

Le modèle TAP, est le modèle qui vous permet (pour faire simple) d’utiliser le couple async/await, dans votre code.

Par exemple avec Windows 8, si je veux lire un flux d’un fichier, je peux à l’aide de la classe HttpClient et de sa méthode GetStreamAsync utiliser ce modèle comme suit :

Code Snippet

public async void LoadDataAsync()
{
var stream = await _clientHttp.GetStreamAsync(new Uri("..."));
}

Ceci est rendu possible, car la méthode GetStreamAsync retourne un Task<Stream>

Néanmoins, avec la classe WebClient de Windows Phone 8, pour lire ce flux, outre le faite que la classe est différente par rapport à celle de Windows 8, la méthode se nomme OpenReadAsync, et ne retourne qu’un void. Pour obtenir le résultat, il faut s’abonner à un évènement (ce que nous évite de faire le modèle TAP justement et qui simplifie la lisibilité du code.)

Code Snippet

public voidLoadRemoteFileAsync(string RemotePath)
{
WebClient _clientWeb = new WebClient();
_clientWeb.OpenReadAsync(new Uri(RemotePath));
_clientWeb.OpenReadCompleted += _clientWeb_OpenReadCompleted;
}
void _clientWeb_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
{
//....Code omis pour plus de clart
}

Une des solutions consiste alors à utiliser une classe bien pratique en .NET la TaskCompletionSource.

Tout d’abord nous allons créer une méthode d’extension pour la classe WebClient, que je nommerai GetStreamAsync (pour utiliser la même nomenclature que la classe HttpClient et ceci afin de rendre plus lisible mon code, dans l’optique ou je vais créer une base de code commune entre Windows 8 et Windows Phone 8, mais ceci est une autre histoire.)

Pour ce faire, il faut déclarer une classe statique et une méthode statique dans cette classe prenant le paramètre this du type de la classe qu’on veut étendre, puis le paramètre de la méthode.

Code Snippet

public static class WebClientEx
{
public static Task<Stream> GetStreamAsync(this WebClient webClient, String requestUri)

Ensuite dans le corps de la méthode nous utilisons la classe TaskCompletionSource, de la manière suivante :

Code Snippet

public static class WebClientEx
{
public static Task<Stream> GetStreamAsync(this WebClient webClient, String requestUri)
{
OpenReadCompletedEventHandler completedHandler = null;
if (webClient == null)
{
throw new ArgumentNullException("webClient");
}
TaskCompletionSource<Stream> tcs = new TaskCompletionSource<Stream>(webClient);
completedHandler = delegate(object sender, OpenReadCompletedEventArgs e)
{
if (e.Error != null)
{
tcs.TrySetException(e.Error);
}
else if (e.Cancelled)
�� {
tcs.TrySetCanceled();
}
else
{
tcs.TrySetResult(e.Result);
}
webClient.OpenReadCompleted -= completedHandler;
};
webClient.OpenReadCompleted += completedHandler;
webClient.OpenReadAsync(new Uri(requestUri));
return tcs.Task;
}
}

On crée un objet TaskComptetionSource qui retournera un Stream
On crée un délégué qui a la même signature que l’évènement OpenReadCompleted que nous lui affecteront par la suite.
Dans ce délégué, on utilise la méthode TrySetResult, qui retourne à l’appelant le Stream du fichier lorsque l’évènement OpenReadCompleted est déclenché.
Pour attendre que l’évènement OpenReadCompleted soit déclenché, on retourne une tâche générée par le TCS.

Du coup maintenant nous pouvons utiliser la syntaxe async/await en utilisant notre méthode d’extension sur la classe WebClient.

Code Snippet

public async voidLoadRemoteFileAsync(string RemotePath)
{
WebClient _clientWeb = new WebClient();
var stream = await _clientWeb.GetStreamAsync(RemotePath);
}

Eric

Tips & Tricks : Dé-sérialisation d’un flux XML avec la WinRT

EVBB — Sat, 20 Oct 2012 05:46:08 GMT

Bonjour,

J’ai un document XML que je voudrais dé-sérialiser à l’aide des méthodes classiques de .NET

Code Snippet

<?xml version="1.0" encoding="utf-8"?>
<Collection MaxLevel="7" TileSize="256" Format="jpg" NextItemId="121" ServerFormat="Default" xmlns="http://schemas.microsoft.com/deepzoom/2009">
<Items>
<Size Width="600" Height="600" />
<Size Width="600" Height="600" />
<Size Width="600" Height="600" />

La 1ère étape consiste a créer une classe en C# qui me permettra de mapper les éléments XML, en éléments plus compréhensible par mon code.

Soit j’écris cette classe manuellement, soit j’utilise l’outil XSD.EXE pour le faire automatiquement.

Outil que vous retrouverez dans ce répertoire : C:\Program Files (x86)\Microsoft SDKs\Windows\v8.0A\bin\NETFX 4.0 Tools

- Tout d’abord il me faut un schéma XSD que je n’ai pas. Pas de soucis nous allons le créer.

XSD.EXE MonFichier.xml /OutPutDir:C:\Temp

Cette ligne créée un fichier MonFichier.xsd

- Ensuite il faut créer la classe en elle même à partir de ce dernier fichier

XSD.EXE MonFichier.xsd /Classes /Language:CS

Cette ligne créée un fichier MonFichier.cs que vous pourrez incorporer dans votre projet.

Mais dans l’état actuel des choses, dans un projet Windows 8 pour le Store (WinRT), le fichier CS, ne compile pas, il faut le modifier manuellement.

En effet l’outil y injecte des espaces de noms et des classes qui sont exclues du sous ensemble .NET utilisable avec la WinRT.

Par exemple, vous pourrez supprimer manuellement toutes les références aux espaces de noms :

[System.SerializableAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]

Tout va bien, tout compile, vous pouvez donc dé-sérialiser votre fichier xml, avec un code du style :

Code Snippet

public class Helper
{
static HttpClient _clientHttp;
static Helper()
{
_clientHttp = new HttpClient();
_clientHttp.MaxResponseContentBufferSize = int.MaxValue;
}
public static async Task<T> LoadRemoteFileAsync<T>(String RemotePath)
{
T t;
try
{
using (Stream stream = await _clientHttp.GetStreamAsync(RemotePath))
{
t = DeserializeStream<T>(stream);
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
throw;
}
return t;
}
public static async Task<T> LoadLocalFileAsync<T>(String LocalPath)
{
var store = KnownFolders.DocumentsLibrary;
T t; ;
try
{
using (var stream = await store.OpenStreamForReadAsync(LocalPath))
{
t = DeserializeStream<T>(stream);
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
throw;
}
return t;
}
static T DeserializeStream<T>(Stream stream)
{
XmlSerializer deserializer = new XmlSerializer(typeof(T));
Object collection = deserializer.Deserialize(stream);
return (T)collection;
}
}

Mais à l’exécution l’exception suivante est levée

Unable to generate a temporary class (result=1).
error CS0012: The type 'System.Object' is defined in an assembly that is not referenced. You must add a reference to assembly 'System.Runtime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'.

Ceci est du au faite que l’outil à généré des données membres de type Jagged array comme illustré dans le code suivant

Code Snippet

private CollectionItemsI[][] itemsIField;

il suffit de le remplacer par exemple par une liste générique

Code Snippet

private List<CollectionItemsI> itemsField;

Et le tout s’exécute normalement

Tips & Tricks : Méthode Asynchrone et Test Unitaire

EVBB — Fri, 19 Oct 2012 07:17:00 GMT

Le développement Windows 8 sur la plate-forme WinRT impose l’utilisation de méthode asynchrone, ça vous le savez .

Le couple async/await, nous rend de grands services dans la plus part des cas mais pas dans le cas d’un test unitaire.

Imaginons que j’ai une méthode asynchrone en C# qui retourne un Task<T>

Code Snippet

public static async Task<T> LoadLocalFileAsync<T>(String LocalPath)

Ma méthode de test pourrait alors appeler directement ma méthode asynchrone

Code Snippet

[TestMethod]
publicasync void TestMethod1()
{
var t = await Helper.LoadLocalFileAsync<FichesProduits>("test.Dat");
}

Ce type de code, même si cela compile, ne fonctionne pas, et la méthode n’est pas reconnue comme étant une méthode de test. (Avec un coup d’ILDASM, vous comprendrez pourquoi).

Mais async/await ne sont que des sucres syntaxiques pour nous aider. La solution est donc de le faire à l’ancienne, ou plus précisément d’utiliser une autre syntaxe à l’aide à des méthodes d’extension disponibles dans la TPL (Task Parallel Library).

du coup ma méthode de test devient :

Code Snippet

[TestMethod]
public void TestMethod1()
{
try
{
var t = Helper.LoadLocalFileAsync<FichesProduits>("test.dat");
//Wait until the asynchronous operation finish
//You could not use the async/await pattern here
t.Wait(5000);
var op = t.AsAsyncOperation<FichesProduits>();
if (op.Status == AsyncStatus.Completed)
{
//get the result only if the operation has completed
var c = op.GetResults();
NotiFyTester(c);
}
else
{
NotifyError(new TimeoutException());
}
}
catch (AggregateException agrEx)
{
//Get the first exception
NotifyError(agrEx.InnerExceptions[0]);
}
catch (Exception ex)
{
NotifyError(ex);
}
}

Code Snippet

void NotifyError(Exception ex)
{
Assert.Fail(ex.Message);
}
void NotiFyTester<T>(T t)
{
if (t== null)
{
Assert.Fail("The collection is empty !!");
}
}

Bon test

Eric Vernié

ISupportIncrementalLoading : Loading a subsets of Data

EVBB — Mon, 15 Oct 2012 15:04:04 GMT

Download the source : http://aka.ms/q4mity

You could find in my last post http://aka.ms/islchg how to populate an collection of data in background. But in this post I would to explain how to sequentialy load a subset of data, in order to allow a fast & fluid scrolling loading an huge set of data.

First the class has to implement the ISupportIncrementalLoading, IList and INofifyCollectionChanged. For a simplier sample, it’s possible to inherit from the ObservableCollection<T> class instead of the latter two interfaces

Code Snippet

public class IncrementalLoadingCollection<T> : ObservableCollection<T>, ISupportIncrementalLoading

The CCTOR take a delegate as an argument, in order to retrieve a subset of data. This is what you will have to implement.

Code Snippet

//delegate which populate the next items
Func<CancellationToken, uint, Task<ObservableCollection<T>>> _func;

Code Snippet

public IncrementalLoadingCollection(Func<CancellationToken, uint, Task<ObservableCollection<T>>> func, uint maxItems)
{
_func = func;
if (maxItems == 0) //Infinite
{
_isInfinite = true;
}
else
{
_maxItems = maxItems;
_isInfinite = false;
}
}

ISupportIncrementalLoading

Two methods to implement

HasMoreItems, is invoked by the control (GridView or ListView), to know if more items has to be loaded.

Code Snippet

public bool HasMoreItems
{
get
{
if (_cts.IsCancellationRequested)
return false;
if (_isInfinite)
{
return true;
}
return this.Count < _maxItems;
}
}

LoadMoreItemsAsync, is invoked with the variable count argument. This argument is calculated according to several factors :

First, the control need to know the number of objects to virtualize. So count is always equal 1 for the first call to the method.

Then, for an object with a size of 480*680, on a 15 inch screen, with a 1920*1080 resolution, XAML virtualize 24 objects (4 visible objects as you can see on the following picture) , count=24.

By the way, using the DataFetchSize and IncrementalLoadingThreshold attributes, we are able to bypass this value for the same config.

With a DataFetchSize=1, the count is equal 16

With DataFetchSize=5 count=40 and so on.

With IncrementalLoadingThreshold=10, LoadMoreItemsAsync will be call 3 times with 120 virtualized objects (3*40)

It’s up to you to play with these attributes, in order to find the more accurate setting for your application.

With the code attach with this post you could play with sliders to see what’s happened when you use different values.

Now go deeper in the LoadMoreItemsAsync

The return parameter is an IAsyncOperation<LoadMoreItemsResult>. Interface. This interface, is create from the AsyncInfo.Run available in the System.Runtime.InteropServices.WindowsRuntime, with a lambda expression as a parameter. This lambda call the InternalLoadMoreItemsAsync()

The IntenalLoadMoreItemsAsync() goals are :

Calculate the count of subset data (numberOfItemsTogenerate).
Invoke the CCTOR’s _func delegate argument (this is what you have to implement as we can see later), delegate wich populate an intermediate data list.
Agregate the intermediate list with the current list

Code Snippet

public Windows.Foundation.IAsyncOperation<LoadMoreItemsResult> LoadMoreItemsAsync(uint count)
{
return AsyncInfo.Run((cts) => InternalLoadMoreItemsAsync(cts, count));
}
async Task<LoadMoreItemsResult> InternalLoadMoreItemsAsync(CancellationToken cts, uint count)
{
ObservableCollection<T> intermediate = null;
_cts = cts;
var baseIndex = this.Count;
uint numberOfitemsTogenerate = 0;
if (!_isInfinite)
{
if (baseIndex + count < _maxItems)
{
numberOfitemsTogenerate = count;
}
else
{
//take the last items
numberOfitemsTogenerate = _maxItems - (uint)(baseIndex);
}
}
else
{
numberOfitemsTogenerate = count;
}
intermediate = await _func(cts, numberOfitemsTogenerate);
if (intermediate.Count == 0) //no more items stop the incremental loading
{
_maxItems = (uint)this.Count;
_isInfinite = false;
}
else
{
intermediate.AddTo<T>(this);
}
return new LoadMoreItemsResult { Count = (uint)intermediate.Count };
}

Using IncrementalCollection<T>

In order to use this collection, you just has to create your own data model.

Example

Code Snippet

public class DataModel : BindableBase
{
private Uri _uri;
public Uri UriPath
{
get { return _uri; }
set { this.SetProperty(ref _uri, value); }
}
private String _title;
public String Title
{
get { return _title; }
set { this.SetProperty(ref _title, value); }
}
//Use to show the download progress
private int _progress;
public int Progress
{
get { return _progress; }
set { this.SetProperty(ref _progress, value); }
}
//Flag to know if the picture come from a remote source
private Boolean _isRemote;
public Boolean IsRemote
{
get { return _isRemote; }
set { this.SetProperty(ref _isRemote, value); }
}
private String _toolTip;
public String ToolTip
{
get { return _toolTip; }
set { this.SetProperty(ref _toolTip, value); }
}
}

Then implement an algorithm wich populate the data.

In this sample, I pushed 9561 pictures on Azure ( http://devosaure.blob.core.windows.net/images/) and build a really simple algorithm based on the picture name .

Code Snippet

private void GetAzureBlobImagesAsync()
{
uint pageNumber = 1;
_data = new IncrementalLoadingCollection<DataModel>((CancellationToken cts, uint count) =>
{
return Task.Run<ObservableCollection<DataModel>>(() =>
{
//***************************************
//Your code start here
ObservableCollection<DataModel> intermediateList = new ObservableCollection<DataModel>();
for (uint i = pageNumber; i < pageNumber + count; i++)
{
String FileName = String.Format("UrzaGatherer ({0}).jpg", i.ToString());
String RemotePath = String.Format(@"http://devosaure.blob.core.windows.net/images/{0}", FileName);
DataModel item = new DataModel();
item.IsRemote = true;
item.Title = FileName;
item.UriPath = new Uri(RemotePath);
intermediateList.Add(item);
}
pageNumber += count;
return intermediateList;
//*************and finish here**************************
});
}, 9651);
_data.CollectionChanged += data_CollectionChanged;
itemsGridViewIncremental.DataContext = _data;
}

You could find in the source code (http://aka.ms/q4mity) :

A Bing sample (You have to provide your own Bing APPID https://ssl.bing.com/webmaster/developers/createapp.aspx)
A File sample wich load local pictures (pictures you have to copy in the C:\Users\[Your User Name]\AppData\Local\Packages\ericvIncremental_nwdczr7kjtdqt\LocalState

To play with this sample, click right to show the AppBar, and select the button you want.

You will notice it’s possible to disable the virtualisation, with the IncrementalLoadingTrigger = IncrementalLoadingTrigger.None. In this case the GridView doesn’t call the LoadMoreItemsAsync() method but it’s possible to invoke manually the LoadMoreItems depending on what you want for you application.

Eric Vernié

Chargement d’un large volume de données : Gestion de ISupportIncrementalLoading

EVBB — Mon, 15 Oct 2012 13:12:05 GMT

Téléchargez le code source : http://aka.ms/q4mity

Dans un précédant billet http://aka.ms/islchg, j’expliquais qu’il est possible de charger les données en arrière plan en évitant de figer l’interface utilisateur, précepte fort du développement Windows 8.

L’idée de ce billet c’est d’aller un peu plus loin et de fournir une collection générique en C# (IncrementalLoadingCollection) , qui charge les données de manière incrémentale comme son nom l’indique afin de permettre un défilement d’un large volume de données de manière fast & fluid.

Pour ce faire, il faut que la classe implémente entre autre l’interface ISupportIncrementalLoading, qui combinée avec les attributs DataFetchSize et IncrementalLoadingThreshold permettent aux contrôles GridView ou ListView, ou tout autres contrôles qui implémentent ListViewBase de charger séquentiellement des données.

Il faut également que cette classe implémente IList et INofifyCollectionChanged. Mais afin de simplifier ce billet, dans notre exemple nous hériterons directement de la classe ObservableCollection<T> , (Dans le code fournit à cette adresse http://aka.ms/q4mity, vous retrouverez un exemple qui implémente ces deux dernières interfaces)

Code Snippet

public class IncrementalLoadingCollection<T> : ObservableCollection<T>, ISupportIncrementalLoading

Le constructeur de notre classe prend comme paramètre un délégué, qui sera exécuté afin de retrouver un sous ensemble des données. Il prend comme paramètre un CancellationToken afin de pouvoir arrêter le chargement, et une liste de type ObservableCollection encapsulée dans une Task

Code Snippet

//delegate which populate the next items
Func<CancellationToken, uint, Task<ObservableCollection<T>>> _func;

Code Snippet

public IncrementalLoadingCollection(Func<CancellationToken, uint, Task<ObservableCollection<T>>> func, uint maxItems)
{
_func = func;
if (maxItems == 0) //Infinite
{
_isInfinite = true;
}
else
{
_maxItems = maxItems;
_isInfinite = false;
}
}

Gestion de ISupportIncrementalLoading

Pour gérer cette interface, il faut implémenter deux méthodes :

HasMoreItems, qui comme sont nom l’indique est invoquée par le contrôle, pour savoir si il doit déclencher le chargement de plus d’éléments.

Voici un exemple de cette méthode qui gère un nombre d’éléments fini/ou infini, et qui permet d’arrêter le chargement si un arrêt est demandé.

Code Snippet

public bool HasMoreItems
{
get
{
if (_cts.IsCancellationRequested)
return false;
if (_isInfinite)
{
return true;
}
return this.Count < _maxItems;
}
}

LoadMoreItemsAsync, est invoquée par le contrôle qui passe comme paramètre la variable count, et qui est calculé en fonction de plusieurs facteurs.

Tout d’abord, le contrôle à besoin de connaitre le nombre d’objets visuels à afficher et à virtualiser.. Pour cela il exécute toujours une 1ere fois la méthode LoadMoreItemsAsync avec un count=1

Ensuite, pour un objet qui fera 480*680, sur un écran 15” de résolution 1920*1080, le nombre d’objet affiché (Visible à l’écran) sera de 4 et le nombre virtualisé de 20, comme sur l’image suivante : count =24

Les appels successifs seront dans notre cas tous avec un count=24.

Maintenant il est possible d’outrepasser cette valeur en utilisant les attributs du contrôle DataFetchSize et/ou IncrementalLoadingThreshold.

Par exemple sur la même configuration , un DataFetchSize=1, donne une virtualisation de count=16

un DataFetchSize=5 donne une virtualisation de count=40, et ainsi de suite…

L’attribut IncrementalLoadingThreshold, quand à lui indiquera au contrôle d’appeler X fois la méthode LoadMoreItemsAsync lors du 1er chargement des données.

Par exemple sur la même configuration, un DataFetchSize=5 et IncrementalLoadingThreshold=10 donne toujours un count=40 mais exécuté 3 fois d’affiler soit 120 éléments virtualisés. Ensuite lors du défilement, le contrôle redemandera des données avec un incrément de 40.

C’est à vous de jouer sur ces différentes valeurs pour trouver le meilleur compromis. (Dans l’exemple fournit vous pourrez jouer avec des curseurs pour constater les différences de chargement comme illustré sur la figure suivante : )

Détaillons maintenant un peu la méthode LoadMoreItemsAsync

Vous pouvez constater qu’elle retourne une Interface IAsyncOperation<LoadMoreItemsResult>. Pour créer cette interface j’utilise ici la méthode AsyncInfo.Run qui m’est fournit dans l’espace de nom System.Runtime.InteropServices.WindowsRuntime, en lui passant comme paramètre une expression Lambda, qui elle même appel une méthode interne InternalLoadMoreItemsAsync()

Cette dernière à pour but de calculer si besoin est le nombre (numberOfItemsTogenerate) de données à charger en fonction de la variable count.

Puis d’exécuter le délégué (_func) qui est passé au constructeur de la classe afin de générer une liste intermédiaire de données. C’est ce délégué que vous aurez à implémenter afin de retrouver de manière incrémentale les données, comme nous le verrons plus tard.

La liste intermédiaire est en fin agrégée avec la liste courante qui constituera notre liste finale.

Code Snippet

public Windows.Foundation.IAsyncOperation<LoadMoreItemsResult> LoadMoreItemsAsync(uint count)
{
return AsyncInfo.Run((cts) => InternalLoadMoreItemsAsync(cts, count));
}
async Task<LoadMoreItemsResult> InternalLoadMoreItemsAsync(CancellationToken cts, uint count)
{
ObservableCollection<T> intermediate = null;
_cts = cts;
var baseIndex = this.Count;
uint numberOfitemsTogenerate = 0;
if (!_isInfinite)
{
if (baseIndex + count < _maxItems)
{
numberOfitemsTogenerate = count;
}
else
{
//take the last items
numberOfitemsTogenerate = _maxItems - (uint)(baseIndex);
}
}
else
{
numberOfitemsTogenerate = count;
}
intermediate = await _func(cts, numberOfitemsTogenerate);
if (intermediate.Count == 0) //no more items stop the incremental loading
{
_maxItems = (uint)this.Count;
_isInfinite = false;
}
else
{
intermediate.AddTo<T>(this);
}
return new LoadMoreItemsResult { Count = (uint)intermediate.Count };
}

Utilisation de la classe IncrementalCollection<T>

pour utiliser cette classe il vous suffira de créer votre modèle de données qui sera lié à votre XAML. par exemple :

Code Snippet

public class DataModel : BindableBase
{
private Uri _uri;
public Uri UriPath
{
get { return _uri; }
set { this.SetProperty(ref _uri, value); }
}
private String _title;
public String Title
{
get { return _title; }
set { this.SetProperty(ref _title, value); }
}
//Use to show the download progress
private int _progress;
public int Progress
{
get { return _progress; }
set { this.SetProperty(ref _progress, value); }
}
//Flag to know if the picture come from a remote source
private Boolean _isRemote;
public Boolean IsRemote
{
get { return _isRemote; }
set { this.SetProperty(ref _isRemote, value); }
}
private String _toolTip;
public String ToolTip
{
get { return _toolTip; }
set { this.SetProperty(ref _toolTip, value); }
}
}

Puis d’implémenter l’algorithme qui retrouve les données.

Dans notre exemple, j’ai copié 9561 images sur un blob Azure dont l’adresse est http://devosaure.blob.core.windows.net/images/

Je passe au constructeur de la classe IncrementalCollection, une expression Lanbda qui implémente un algorithme très simple et basé sur le nom des images qui va de UrzaGatherer (1).Jpg à UrzaGatherer (9561).jpg. J’incrémente une variable pageNumber, qui me permet de retrouver les images en fonction du nombre count passé en paramètre.

puis je construit une liste intermédiaire que je retourne et qui sera utilisé par la méthode LoadMoreItemsAsync. N’oubliez pas que , que c’est cette dernière qui exécutera cette lambda.

Code Snippet

private void GetAzureBlobImagesAsync()
{
uint pageNumber = 1;
_data = new IncrementalLoadingCollection<DataModel>((CancellationToken cts, uint count) =>
{
return Task.Run<ObservableCollection<DataModel>>(() =>
{
//***************************************
//Your code start here
ObservableCollection<DataModel> intermediateList = new ObservableCollection<DataModel>();
for (uint i = pageNumber; i < pageNumber + count; i++)
{
String FileName = String.Format("UrzaGatherer ({0}).jpg", i.ToString());
String RemotePath = String.Format(@"http://devosaure.blob.core.windows.net/images/{0}", FileName);
DataModel item = new DataModel();
item.IsRemote = true;
item.Title = FileName;
item.UriPath = new Uri(RemotePath);
intermediateList.Add(item);
}
pageNumber += count;
return intermediateList;
//*************and finish here**************************
});
}, 9651);
_data.CollectionChanged += data_CollectionChanged;
itemsGridViewIncremental.DataContext = _data;
}

Vous retrouverez dans le code source fournit (http://aka.ms/q4mity), un exemple autour des APIS Bing (Vous devrez alors fournir votre propre APPID (https://ssl.bing.com/webmaster/developers/createapp.aspx)

Ainsi qu’un code qui permet de charger des fichiers images en local. Pour ce dernier exercice vous devrez copier des fichiers images dans le répertoire suivant de l’application :C:\Users\[Votre nom d’utilisateur]\AppData\Local\Packages\ericvIncremental_nwdczr7kjtdqt\LocalState

Pour exécuter le code fournit, il suffit après le chargement de l’application, cliquez droit sur la souris pour faire apparaitre l’Appbar qui contient les commandes a exécuter.

Vous noterez qu’il est possible de débrayer le chargement incrémental en cliquant sur la case à cocher Virtualisation, qui positionne par liaison de donnée l’attribut IncrementalLoadingTrigger = IncrementalLoadingTrigger.None

Dans ce dernier cas, le contrôle n’exécute pas la méthode LoadMoreItemsAsync(), c’est à vous de le faire explicitement. Ce scénario peut être intéressant, lorsque vous souhaitez vous même gérer le chargement incrémentale.

Eric Vernié

Cook your App

EVBB — Mon, 24 Sep 2012 06:36:09 GMT

Si vous êtes un roi du développement, venez vous essayer au concours Cook You App et gagner un voyage à la conférence //BUILD/ à Redmond.

Eric