Cette session était consacrée à la présentation de la librairie « Windows® API Code Pack for Microsoft® .NET Framework » développée par Microsoft et disponible avec les sources sur MSDN Code Gallery (http://code.msdn.microsoft.com/WindowsAPICodePack). Cette librairie offre un ensemble de wrapper dont le but est de bénéficier des nouvelles fonctionnalités de Windows directement en code managé comme C# et VB.NET. Ces nouvelles fonctionnalités sont les suivantes :

• La nouvelle barre des tâches
• La gestion des capteurs
• Le multi touch
• DirectX (il n’y avait presque rien à dire sur le sujet)

Contrairement aux dernières versions de Windows 7, aucune librairie managée n’était proposée par Microsoft pour développer au travers des API natives avec les nouvelles possibilités du système d’exploitation. Trois choix s’offraient donc à vous :

1. Développer vos propres wrapper
2. Réutiliser les exemples des SDK
3. Attendre les Service Pack du .NET Framework

Microsoft prend donc les devant en nous proposant directement les sources de ses wrapper. Comme dit précédemment, ils sont disponibles sur MSDN Code Gallery en version finale mais seront intégrés au plus vite dans le .NET Framework 4 via un Service Pack.

Lors de la partie consacrée à la gestion de la nouvelle barre des tâches de Windows 7, nous avons vu comment réaliser différentes possibilités :

• Récupérer les informations de la barre des tâches de Windows au travers du singleton TaskBarManager.
• Créer des références d’éléments dans le menu contextuel grâce à la classe JumpList.
• Créer des groupements d’éléments dans le menu contextuel via la classe JumpListCustomCategory.
• Réagir en conséquence lors de la sélection d’un élément dans le menu contextuel.
• Manipuler la barre de progression pour les opérations longues.
• Visualisation d’une miniature de l’application (malheureusement, il n’a pas été possible d’aborder cette fonctionnalité vu le manque de temps).

La seconde partie est consacrée aux capteurs avec l’utilisation d’une carte à circuit imprimés comportant plusieurs capteurs dont :

• Un capteur de lumière
• Un capteur accéléromètre
• Un capteur gps

Microsoft propose une moyen de communication unifié pour l’interaction des capteurs de votre machine avec votre code. Le but étant de ne plus devoir passer par des API propriétaires.

Vous pouvez d’ailleurs gérer vos capteurs au travers du panneau de configuration de Windows : « Emplacement et autres capteurs ».

La démonstration consistait à répercuter les données des capteurs accéléromètres et de lumière dans un environnement 3D :

• Lorsqu’on déplaçait la carte à puce, on pouvait se déplacer dans l’environnement 3D
• Lorsqu’on jouait avec la lumière captée par le capteur de lumière, on pouvait voir l’environnement 3D s’assombrir ou devenir plus lumineux.

La dernière partie était consacrée au multi touch avec Windows 7. Une autre API est proposée par Microsoft via CodePlex. Malheureusement, je n’arrive pas à remettre la main sur le lien du projet.

Il est à noter que cette API est différente est différente de celle proposée pour Microsoft Surface mais elles seront unifiés dans le futur pour ne pas être obligé de réécrire du code adaptez à une tablet PC pour une table surface.

La démonstration expliquait comment intercepter les éléments qui interagissent avec l’écran tactile au moyen d’événements.

• Windows Server 2008 R2 pour les IT, avec de nouvelles avancées en terme de virtualisation avec le basculement à chaud de vos machines virtuelles mais aussi un nouvel outil nommé RemoteApp qui permet l’exécution d’anciennes applications compatibles uniquement avec des anciennes versions de Windows.

• Visual Studio 2010 pour les développeurs, présentation des dernières nouveautés de l’éditeur, les avancées pour les tests encore une fois plus facile et rapide à mettre en ouvre.
• SQL Server 2008 R2, s’alignant à présent avec la dernière version de Windows Server pour le nombre maximum de cours processeurs supportés.
• La plateforme Windows Azure, avec présentation de l’interopérabilité de vos applications Java et PHP dans le cloud de Microsoft.

Cette plénière était aussi l’occasion d’annoncer les prochaines versions des processeurs Intel autant sur les postes clients que serveurs. Ci-dessous, les deux photos que j’ai pu prendre sur ces nouveaux processeurs.

Pour finir, nous avons eu droit à une démonstration d’une application Silverlight couplée avec DeepZone permettant de se balader dans des photographies de très grandes qualités avec des renseignements attachés sur des éléments au sein de ces photographies.

Pour ceux qui ne le savaient pas, la plénière d’aujourd’hui était retransmise pour la première fois en direct sur internet. Et il en sera de même pour les plénières du mardi et du mercredi. Rendez-vous donc à l’adresse suivante dès 9h00 : http://windows.developpez.com/live-techdays-2010/

Vous retrouverez ci-dessous mes différents écrits relatifs aux sessions auxquelles j’ai eu l’occasion d’assisté et qui méritaient selon moi un petit focus :

• Jour 1 – 09h30 à 10h30 – Conférence plénière : infrastructure et développement des systèmes d’informations agile
• Jour 1 – 11h00 à 12h00 – Comment tirer parti de Windows 7 dans vos applications .NET ?
• Jour 1 – 13h00 à 14h00 – Visual Studio 2010 et TPL

J’allais oublier, saviez-vous que notre communauté est présente encore cette année aux TechDays ? Pour nous trouver, rien de plus simple car nous sommes juste à côté du stand MSDN (là où vous pouvez avoir du pop corn :p). Je vous conseille de bien surveiller nos forum, twitter, page facebook, index et blogs car il n’est pas impossible qu’il y ait quelques t-shirts WIFI à remporter. Wait & see !

Ne sachant donc plus ce à quoi je voulais assister, j’ai pris la première session qui parlait de Visual Studio 2010 et qui était donc Visual Studio 2010 et TPL.

Cette session est consacrée au développement parallèle au travers de votre code managé dont trois fonctionnalités importantes furent abordées :

1. PLinq
2. Utilisation des tâches
3. Les collections concurrentes (qui n’a pas été abordé pas manque de temps)

PLinq est en fait un provider Linq parallélisé afin d’exécuter des requêtes sur vos différents processeurs. Même si nous avons vu qu’il est très facile de réécrire une requête Linq simple en requête PLinq, Vincent a attiré notre attention sur quelques points et pièges à éviter.

Par rapport à une requête Linq, la version PLinq ne sera jamais autant de fois plus rapide qu’il y a de processeurs sur votre machine. Pour faire simple, une requête Linq, qui prend 2 secondes avec une machine munie de deux processeurs, ne s’exécutera pas deux fois plus vite en PLinq. La raison est que PLinq est beaucoup plus lourd car il entraine un certain nombre de synchronisation en différents threads qui sont générés. On pourra donc considérer qu’une requête PLinq sera 1,67 fois plus rapide plutôt que 2 fois.

Un piège à éviter est l’utilisation de ce genre de requêtes en Linq to SQL ou Linq to Entities :

   1: var query = from facture in ctx.Factures.AsParallel()

   2:             select new { factureID = facture.ID, ClientNom = facture.Client.Nom };

Une exception sera générée à l’exécution car cette requête est résolue en deux temps :

• Récupération des données de la table Facture de manière parallèle
• Génération des objets anonymes en retour des données chargées de la base de données

Sauf que seules les données de la table Facture ont été récupérées. Les données relatives au client ne le seront pas contrairement à ce que font les ORM Linq. Il va donc être nécessaire de modifier notre requête pour inclure les données de la table Client. Je n’ai pas d’exemple à vous montrer tellement la requête est devenue compliquée pour arriver au résultat espéré.

La seconde partie de la session est l’utilisation des tâches permettant de créer des threads plus facilement et de manière hiérarchique. Différentes classes sont mises à disposition :

• Task : tout simplement notre tâche
• TaskScheduler : le scheduler de tâches qui est une classe abstraite
• TaskFactory : permettant de créer plus facilement un ensemble de tâches ayant le même scheduler, les mêmes options et aussi les mêmes systèmes d’annulation
• CancellationTokenSource et CancellationToken : pour la gestion des annulations de tâches

Après une démo de mise à niveau d’une application écrite avec l’utilisation de threads classiques pour utiliser au final des tâches, une partie du sujet a été consacré au debugging avec la présentation de nouvelles fenêtres dans Visual Studio et qui permettent de visualiser les tâches parallèles, les piles d’appels, qui bloque qui, les états.

Il est aussi possible de collecter automatiquement un ensemble d’informations lors de l’exécution de votre application au travers de Visual Studio afin de générer un rapport et analyser de manière graphique sur une échelle de temps tout ce qui s’est déroulés au niveau des threads.