Une absence prolongée prenant fin en ce premier jour des Techdays 2010

7 minutes read

Bien le bonjour à tous.

Comme le titre de ce billet pouvait le laisser entendre, John est de retour sur la blogosphère. Et pour ceux qui n’auraient pas suivi John c’est moi. Alors pourquoi une telle absence ? Plusieurs réponses sont possibles à cela mais une seule est valide. Alors non je ne suis pas devenu papa, non je ne me suis pas marié, non je ne suis pas mort (preuve en est). J’étais tout simplement bien occupé par mon nouveau travail et par mes activités extérieures. J’ai cependant réussi à stabiliser mon emploi du temps ce qui devrait me permettre de rebloguer.

Mais pour bloguer encore faut-il avoir des choses intéressantes et utiles à dire. Ce n’est généralement ni une tâche aisée pour moi de trouver une idée, ni facile de bien présenter le sujet. Or avec l’arrivée des nouveaux produits Microsoft cette année je vais avoir matière à écrire. Je vais donc continuer ce blog par un retour sur cette première (et dernière journée en ce qui me concerne car je dois bosser les autres jours) des Techdays 2010. Et maintenant donc le vif du sujet. Lors de la plénière nous avons eu le droit à un petit aperçu fort bien présenté de System Center, Visual Studio 2010, l’agilité avec les tests unitaires via ce dernier et pour finir azure, le tout sur une ambiance jeu télé à la “Qui veux gagner des téras” et finissant sur la musique de “Never AFK”.

En ce qui concerne System Center j’ai retenu deux choses :

  • Gestion du déplacement des machines virtuelles à chaud sans que les utilisateurs de ces dernières ne s’en rendent compte (exemple prit d’une copie d’un gros fichier lors du déplacement de cette VM)
  • Gestion des polices droits d’exécution sur les applications (exemple du blocage de Windows Live Messenger par un administrateur)

En ce qui concerne Visual Studio et l’agilité j’ai appris que nous ne faisions pas de tests et que nous étions fainéants et qu’il fallait vraiment remédier à cela. Mais en fait c’est pas une nouveauté ;-) Et en ce qui concerne Azure les deux principales choses que je retiendrai sont le fait de pouvoir déployer des projets dans d’autres langages que ceux du monde .NET (tels que PHP dont l’exemple nous a été monté) et la “version Cloud” de SQL Server dénommée SQL Azure interrogeable par des applis hors du Cloud (exemple d’une application en VB6 interrogeant une base SQL Azure).

J’ai ensuite assisté à la session de Mitsuru Furuta et Thomas Lebrun sur les nouveautés de WPF 4. Ils nous ont donc parlé de l’unification des différentes technologies de présentation (touch, Surface, souris multiples, speech, intégrations améliorés dans Windows 7), de l’orientation métier des applications et de l’alignement progressif avec Silverlight. Thomas nous a ensuite montré de nouvelles fonctionnalités graphiques et/ou d’animations :

  • TextFormattingMode permettant de corriger les problème de lisibilité des textes lors de l’utilisation de polices de petites tailles
  • ClearTypeHint permettant de spécifier au moteur le type de lissage à effectuer.
  • LayoutRounding permettant de corriger certains problèmes d’affichages étranges avec WPF.
  • EasingAnimation qui fonctionnent comme en Silverlight
  • VisualStateManager qui fonctionnent aussi comme en Silverlight
  • Et ma préférée les CachedComposition qui permet de mettre en cache le Bitmap d’un contrôle afin que le layout ne soit pas recalculé à chaque frame tout en restant interactif ce qui se traduit par un gain de performance. Le principal problème étant le crénelage lorsque l’on zoom sur le contrôle.

La partie suivante de cette présentation s’est articulé autours des contrôles et des outils intégrés dans WPF 4 :

  • DataGrid, Calendar, DatePicker.
  • Editeur de ressources, de binding, palette de couleurs.
  • Custom Speller Dictionary permettant de fournir un dictionnaire de mots correctement orthographiés.
  • Ajout du Binding de commandes (probablement ma préféré du lot) qui nous evite donc la création d’une classe intermédiaire comme avant.
  • Binding sur les types dynamiques
  • Binding dans les FlowDocument \o/

La fin de cette session portait sur les interactions avec Windows 7 :

  • JumpLists personnalisables avec le support de la prévisualisation, lancements d’executables etc…
  • Multitouch, Manipulation comme ce qui pouvais se trouver dans le sdk de Surface

Pour conclure sur cette session je dirai que j’en suis très satisfait. Ayant eu a délaisser WPF plus que ce que j’aurai voulu ces derniers temps, je suis content de voir les améliorations et de voir que ce que j’ai appris sur Surface me sera utile avec l’api multitouch de Windows 7 et WPF 4. Après une pause déjeûner fort courte et une recherche du stand de ma société j’ai pu assister à la session sur les nouveautés de C# 4. Cette session récapitulait et présentait les nouveaux concepts liés aux types dynamiques, aux paramètres nommés, à la co-variance et à la contra-variance ainsi qu’aux expressions.

Pour ce qui est des types dynamiques j’ai principalement pu noter les éléments suivants :

  • Conversion automatiques vers les types de retour attendus
  • Résolution des types, des propriétés, des méthodes
  • En C#, le mot clef dynamic est un alias vers le type DynamicObject
  • Introduction de l’ExpandoObject qui se comporte comme un objet en JavaScript

De nouvelles façon de passer des paramètres aux méthodes furent aussi présentés :

  • Les paramètres optionnels doivent toujours finir la signature des méthodes
  • Utiliser des paramètre nommés créer des dépendences sur les noms de ces derniers ce qui peut poser des problèmes en cas de refactoring.

A propos de la co-variance et de la [contra-variance](http://msdn.microsoft.com/en-us/library/dd799517(VS.100).aspx :

  • La co-variance et la contra-variance ne marche qu’avec les types génériques et les délégués
  • Une réécriture de la plupart des interfaces du framework de base ou la co-variance et la contra-variance avaient un sens a été faite (IEnumerable, IEnumerator, IQueryable, IComparer etc..)
  • Déclarer un type co-variant ou contra-variant se fait en jouant les les types de paramètres (exemple IMyGeneric<in T> ou bien IMyGeneric<out T>)

Cette session s’est terminé sur les expressions avec l’introduction succinte de leurs fonctionnalités (telle que la construction dynamique de lambdas par exemple) ainsi que sur le fait que Linq est désormais un sous-ensemble de la DLR.

S’en est suivi une session beaucoup plus “barbu” sur la programmation parallèle en C++. Session très interessante grâce à laquelle j’ai pu constater les points communs entre les Parallel Extensions et le code natif. Je ne détaillerai pas ici cette session car elle est hors sujet de ce blog mais j’essaierai de parler de la programmation multi-thread dans un autre billet de ce blog ou je soulignerai les liens entre le code natif et le code managé dans la gestion de cette dernière. L’avant dernière session à laquelle j’ai pu assister est une session sur le futur de XAML :

  • Xaml a été déplacé dans System.Xaml.dll et est donc utilisable en temps que langage de sérialisation à part entière sans avoir à référencer les dll WPF dans les projets qui n’ont rien à voir avec ce dernier.
  • ValueSerializer pour générer des syntaxes raccourcies.
  • XamlReader et XamlWriter sont maintenant des classes abstraites dont dérivent les différents types de Reader/Writer Xaml (exemple XamlXmlWriter)
  • Convergence des différents types de parser Xaml, Xoml
  • Présentation des différents types de conversions à l’aide de Xaml (Binary, Object, Dom, Xml)

Une liste des améliorations de Xaml dont on nous as parlé :

  • Plus besoin de faire un import de mscorlib pour déclarer des types comme int, string etc…
  • x:TypeArguments support désormais les types génériques
  • Introduction de x:Reference pour le binding
  • Possibilité de passer des paramètres aux constructeurs des objets en Xaml grâce à x:Arguments ou x:FactoryMethod

Introduction d’un moteur de parcours/lecture/écriture de Xaml nommé XamlDOM (présent dans un toolkit du nom de Xaml Toolkit) :

  • Permet de générer du Xaml de manière plus concise
  • Supporte les requêtes Linq
  • Intégration avec FxCop (BaseXamlRule)

Et enfin présentation d’un nouveau moyen de localiser vos applications WPF/Silverlight avec x:Uid Mistu nous as fait une démo ayant pour objet de sérialiser une Expression en Xaml et de l’évaluer. Une sorte de calculatrice assez inhabituelle dont le code est lisible en Xaml. Pour résumer cette session on peux dire que Xaml est désormais un langage de sérialisation vraiment indépendant de WPF et donc utilisable dans divers types de projets. La création de sérialiseurs personalisés est assez triviale et permet donc de créer des raccourcis de notation un peu à la manière de {Binding Path=MyProperty} en WPF.

J’ai ensuite fini ma journée avec Coding4Fun qui m’a permis de bien rigoler et de me détendre en voyant :

  • un robot contrôlé par Silverlight 4 tenter de répérer les possesseurs d’Iphone dans la salle.
  • un tetris initialement développé sur Pocket PC jouable via des boutons tout moches dans la prévisualisation des programmes de Windows 7.
  • un device multi-touch custom communicant les informations de points par réseau via UDP à la manière bourrin et par system de fichiers (ce qui est encore plus bourrin à mon goût).

Bref une session techniquement amusante si je puis dire \o/. Il est dommage que ces Techdays s’arretent pour moi en ce lundi 8 février, je me rattraperai avec les webcasts !

Updated:

Leave a Comment