Le magazine IT-Pro propose de télécharger le PDF de son dernier hors série de 12 pages dédié à l'industrialisation des processus de développement.
Au programme: les méthodologies, les outils et les solutions pour optimiser de bout en bout la qualité de vos projets de développement.
Celui-ci est composé de 3 parties:
- Partie 1: Enjeux et mise en perspective par Thomas Petillon
- Partie 2: Comment et pourquoi améliorer les processus de développement par Maxence Dislaire
- Partie 3: Team System et l'industrialisation logicielle par moi même
Vous pouvez télécharger le tout à cette adresse:
http://ittechnicalcenter.itpro.fr/ressources/processus_developpement/
Bonne lecture!
Voici une autre des nouveautés actuellement présente dans la CTP 12 de Rosario (Team System VNext), qui cible ce coup-ci les versions Developpeur et Testeur du produit: le concept de tests unitaires impactés.
Dans VS 2005 / 2008, la fenêtre "Test View" affiche, pour une solution .NET donnée, la liste des tests MSTest présents dans les différents projets de test.
Depuis cette fenêtre il est possible de sélectionner un ou plusieurs tests, de les grouper (par classe cible testée, par namespace, par projet...), et d'initier leur exécution en mode classique ou en débug.
En 2005 / 2008, dans une approche de développement accompagnée de tests unitaires, il est donc requis, à chaque modification d'un bout de code, d'exécuter l'ensemble des tests le validant. Sur un petit projet, il est aisé l'intégrale des tests, mais sur les projets volumineux possédant quelques centaines de tests... :
- Cela peut être une perte de temps considérable de les faire exécuter tous par l'environnement de développement
- Dans le cas d'une sélection "manuelle" des tests à exécuter, il est possible d'en oublier certains, et ceux-ci perdent leur intérêt
- En travaillant en mode "intégration continue" et en exécutant les tests unitaires sur un serveur de build de manière automatique après chaque check-in, les allers retours avec le contrôleur de source pour corriger en cas de problème sont aussi une perte de temps considérable
La solution dans VS Rosario se place au niveau de l'intelligence de l'environnement de développement, toujours dans la fenêtre "Test View" ou la notion de "Test impacté" fait son apparition. A chaque modification d'un bout de code, Rosario identifie ainsi automatiquement la liste des tests le validant et les groupe sous l'intitulé "Recommanded".
Par exemple, suite à une micro modification dans le code, la liste de tests unitaires présente dans mon projet devient automatique groupée de la sorte:
Au vu de de la modification apportée au code, Visual Studio recommande donc l'exécution de 3 tests.
Il est ainsi nécessaire de sélectionner les trois (ou leur groupe) et de les exécuter pour obtenir le résultat suivant (cliquez pour agrandir l'image):
Dans cet exemple la, 2 tests ont réussit, ils sont donc automatiquent regroupés sous l'intitulé "Verified", vu qu'il n'est plus nécessaire de les exécuter (si le code est de nouveau modifié, il reviendront bien sur dans le groupe "Recommanded"). Le 3eme test a part contre échoué, de ce fait, il reste dans l'état "Recommended" car il est nécessaire de le rejouer (et de modifier le code) jusqu'a ce qu'il fonctionne.
Avec Rosario, il est donc ainsi possible de n'exécuter que les tests unitaires utiles. Attention, l'intégralité des tests doivent toujours être joués régulièrement, mais ce travail entre très bien dans le rôle du serveur de compilation Team Build, chargé de le faire à chaque archivage ou chaque nuit!
La CTP 12 de Rosario (Team System VNext) étant maintenant disponible depuis quelques semaines, il est temps de se lancer à la découverte de ses nouvelles fonctionnalités.
La première que je vous propose de découvrir ici, fait partie des nouveautés de Team Build, le serveur / service de compilation disponible avec Team Foundation Server. Team Build est un service permettant d'éxécuter des scripts MSBuild sur un serveur distant, soit à la demande, soit de manière plannifiée (chaque soir a 2h du matin, sauf les vendredi...) ou soit en mode intégration continue après chaque archivage.
Dans les versions 2005 / 2008 de TFS, un assistant permet de générer un script MSBuild de base, largement suffisant dans 80% de cas, réalisant les actions suivantes:
- Extraction des sources depuis Team Foundation Source Control, en s'appuyant sur une solution (sln) cible
- Marquage de celle-ci avec une étiquette (label) en utilisant le numéro de Build (NomBuild_AAAAMMJJ.NumUnique)
- Compilation
- Exécution des tests unitaires
- Exécution d'une analyse statique du code
- Déploiement du résultat de la compilation (DLL, EXE, site web) sur un partage (share) cible
- Génération d'un rapport de compilation (envoie par Email)
Le seul problème avec ceci, c'est que lorsque l'on veut étendre le script, il faut obligatoirement mettre la main directement dans MSBuild, ce qui demande un petit temps d' adaptation et n'est pas très "user friendly" vu qu'il s'agit de modifier de l'XML:
Avec Rosario, le système de définition de Build a été totalement revu, et s'appuit dorénavant sur Workflow Foundation pour définir les différentes étapes. Chaque action devient donc une activité WF et, pour modifier le script, il suffit de changer l'ordre ou la liste des activités présentes dans le script par défault, en s' appuyant sur celles proposées par Rosario. Le tout de manière complètement graphique directement depuis Visual Studio grâce à la fonctionnalité de rehosting de designer offerte par WF.
Le mode d'accès à l'assistant de modification des builds reste inchangé vis à vis des versions actuelles.
Par contre, un nouvel onglet "Process" fait son apparition dans la fenêtre de configuration de Build. Celui-ci est composé de trois zone:
- A gauche, la zone de modélisation du Workflow de Build
- A droite en haut, la liste des activitées disponibles, pouvant être glissées-déposées
- A droite en bas, la zone de configuration des propriétées de chaque activitée
L'extensibilité devient aussi simplifiée, pour ajouter une étape / action, il suffit d'écrire une activité WF (finit les importtask et compagnie donc) et de la déployer sur le serveur de Build.
Hormis la simplicité de modélisation, cela va va apporter de plus la possibilité de paralléliser l'éxécution d'un script de Build sur plusieurs machines et la simplification du debuggage des process de build.
En temps que fan de Team System et de Workflow Foundation, je ne peux que me réjouir de tout ceci :)
Bon, Orcas, ou plutôt Visual Studio 2008 / Team Foundation Server 2008 sont livrés et installés depuis plus d'une semaine. Histoire de garder un train d'avance et d'anticiper l'avenir en remontant des feedbacks, il est maintenant possible de se concentrer sur la VNext de Visual Studio Team System, un peu ignorée jusqu'à présent (mais pourtant disponible en CTP depuis plusieurs mois), nom de code "Rosario", qui sera pourtant une release majeure de la gamme Visual Studio Team System.
Au programme: ajouts de fonctionnalitées dans les éditions "Team" (et notamment architecte longtemps oubliée!) et dans le serveur Team Foundation.
Pour le téléchargement de la VPC contenant toute l'installation, cela se passe par ici:
(source et détails: Jeff Beehler)
Allez hop, téléchargement en route dès cette nuit!
Voila, c'est finit pour cette année, me voici de retour a Paris (enfin Bruxelles ce Week end pour être exact).
Ce fut mon premier Teched, l'occasion pour moi de sortir de mon quotidient d'expertise habituel (Team System) et d'aller découvrir des nouveautés pour l'instant inexplorée tout en écoutant des speakers vraiment de qualité (et d'en prendre de la graine).
Voici donc la liste des 22 différentes sessions vers lesquelles mon choix s'est porté durant ces 5 jours:
Si je devais définir un prix du meilleur speaker, il irai sans hésiter a Roy Osherove. Concernant la session ou j'ai techniquement pris le plus de plaisir, il s'agirait de "Building Workflow Enabled and Durable Services using .NET 3.5"
J'avoue avoir été impressionné par l'organisation de l'événement, surtout par la couverture réseau (wifi + fillilaire) ayant permis à l'ensemble de geeks présents d'être connecté sans arrêt à Internet pendant et hors des sessions et de recharger leurs batteries aux intersessions.
Cet événement a aussi été surtout l'occasion de rencontrer beaucoup de personnes intéressantes, que cela soit dans un contexte personnel ou professionnel.
Je pense sincèrement que je vais avoir besoin d'une bonne semaine de repos pour me remettre du rythme effroyable de cette semaine (couché en moyenne a 3h30 du mat et levé a 8).
En conclusion, je tiens à remercier ma société (Winwise) ainsi que Microsoft pour m'avoir permis de participer à cette formidable semaine!
Roy Osherove - SELA Group www.ISerializable.com (blog)
Dernière session pour de ce Teched 2007.
Session niveau 400 sur les nouveautés de la Reflection 2.0 tels que la génération de code au runtime en utilisant DynamicMethod, le parsing de IL au runtime, la reflection sur les generics, le debuggage de code autogénéré, Reflection.Emit et la génération de IL pour gagner en performance.
On va dire que je me suis plutôt concentré sur le contenu plutôt que de prendre des notes :)
Une session qui méritera d'être regardé en Webcast dès que disponible.
J'ai cependant été étonné de voir une des plus grandes salles de la conférence complètement pleine pour un sujet pourtant ultra spécifique et touchant normalement qu'un très faible public.
Matt Gibbs - ASP.NET Development Manager
Sans hésitation la session la plus attendue de la journée de mon coté depuis la récente annonce il y'a trois semaines de Scott Guthrie sur l'apparition d’un Framework MVC pour ASP.NET (salle d'ailleur pleine).
Rappel sur la roadmap ASP.NET: ASP.NET AJAX 1.0 => .NET Framework 3.5 (ASP.NET 2.0 + features) => nouveau .NET Framework annoncé au milieu de l'année prochaine
MVC en général: Maintient une séparation propre des différentes couches applicatives
- Facilement testable en TDD (la couche graphique est réduite à l'affichage de l'HTML)
- Facile a maintenir
- Les vues ne contiennent pas de logique métier
- Les vues n'ont pas la connaissance des couches inférieures
ASP.NET MVS Framework:
Intégré avec ASP.NET:
- Utilisation possible des fonctionnalités standards tels que le cache, la session, le profile..
- Support des langages statiques standards mais aussi des dynamiques
Ajout d'outils:
- Intellisense, refactoring, debug
- Modèles de projets
- Les view .aspx concernant le mode design de Visual Studio
ASP.NET MVC Framework n'est pas WebForms 4.0, c'est battit sur ASP.NET 2.0 et fonctionne bien avec des frameworks existants tels que NHibernate, Castle ou Brail.
Cycle de fonctionnement:
- Le serveur Web récupère la requête du navigateur
- Elle est redirigé vers le contrôleur
- Celui ci est activé
- Les actions du contrôleur sont appelées
- Le contrôleur travaille avec le modèle et la saisie utilisateur
- Le contrôleur génère une vue
- L'url de sortie pointe vers le contrôleur
Request => Route => controller => ViewFactory => View => Response
Comment cela marche: Les requête HTTP sont redirigées sur le contrôleur, et plus sur la page .aspx, le contrôleurs est ensuite chargé de sélectionner la vue (la page) à afficher.
Un des gros avantages de l'utilisation de MVC est que cela simplifie la phase de test de l'application: beaucoup d'éléments sont remplaçables par des mocks: IHttpContet, IHttpResponse, IHttRequest. Il n'est pas cependant nécessaire d'utiliser ceux-ci pour remplacer tout ASP.NET: La factory de génération de page seule est facilement utilisable.
Une session très intéressante pour un sujet qui mérite d'être plus creusé (je n'ai pas été convaincu personnellement, donc il va falloir essayer de mettre en place tout ça rapidement)
Pour aller plus loin:
- Blog de Scott Guthrie: http://weblogs.asp.net/scottgu/archive/2007/10/14/asp-net-mvc-framework.aspx
Matt Gibbs - ASP.NET Development Manager Microsoft
Une session sur les différents projet d'ajout de fonctionnalités à ASP.NET étant actuellement dans les bacs chez Microsoft.
Astoria:
Nom de code d'un projet dont le but est de permettre d'exposer très facilement depuis vos applications des données en temps que service de données: interrogeables ensuite via HTTP en utilisant les requêtes classiques GET, POST, PUT et DELETE. Le format des données échangées est ensuite bien sur configurable, par exemple il est possible de choisir XML ou JSON pour le transport.
AJAX dans Orcas:
Mise à jour des validateurs, du TreeView, Menu et des WebParts
Ajout des fonctionnalités de navigation logique dans les pages utilisant Ajax: possibilité d'utiliser le bouton "Back" pour revenir en arrière grâce a des API client et serveur API qui sont en charge de stocker les titres et URL des pages dans un historique et de créer des liens permanent avec reconstitution de l'état:
- Utilisation par exemple d'une méthode JavaScript: "ScriptManager.AddHistoryPoint(...)"
ASP.NET Ajax Script Combining: permet de regrouper un ensemble de fichiers de scripts dans un seul fichier afin d'optimiser le trafic client / serveur (celui-ci sera ensuite mis en cache du coté du navigateur comme un script classique).
ASP.NET Silverlight Controls:
- ASP:SilverlightControl: Automatise le processus de demande d'installation du plugin au client.
- Silverlight Plugin Helper Classes: Permet d'instancier le plugin Silverlight par code et d'interagir avec des composants Silverlight coté client ou coté serveur.
- ASP:MediaPlayer: embarquement de vidéo dans ASP.NET, nombreux skins disponibles et très facilement personnalisable, découpage en chapitre de la vidéo facilité, ajout de sous titre, localisation
ASP.NET Dynamic Data:
Remplace le projet BLINQ. Permet de générer à partir d'une base de données une application Web complètement CRUD se basant sur le schéma cible, avec prise en compte de la navigation entre les différentes relations.
ASP.NET MVC Framework:
Je ne vais pas détailler ici cette nouveauté étant donné que je vais voir une session
consacrée uniquement au sujet en début d'après midi.
Une belle session rapide et intéressante sur les différents projets en cours devant être disponibles normalement dans le courant de l'année prochaine.
Quelques liens:
- Astoria overview: http://astoria.mslivelabs.com/Overview.doc
- ASP.NET Future: http://www.microsoft.com/downloads/details.aspx?FamilyID=9323777e-fe78-430c-ad92-d5be5b5ead98&DisplayLang=en
- Dynamic Data Control: http://blogs.developpeur.org/azra/archive/2007/07/25/dynamic-data-controls-une-interface-web-d-dition-de-base-de-donn-es-en-quelques-clics.aspx#comments
Thomas Quinn - Architect, Visual Studio Team, Microsoft Corporation
Après la session sur Visual Studio Shell "comment étendre Visual Studio pour créer un environnement de développement personnalisé", cette session sur Visual Studio Tools for Applications répond à une autre question: "comment proposer facilement un système d'extensibilité de mes applications".
Visual Studio Tools for Office (VSTO) est un système d'extensibilité à la gamme client office permettent de facilement développer des addins en .NET pour ajouter des fonctionnalités à Word, Excel, Outlook... VSTO est en réalité bâtit a VSTA, qui permet donc de proposer le même modèle de développement d'addin pour vos applications. Ceci se traduit par plusieurs éléments d'interactions avec le développeur:
• Proposition d'un modèle de projet "nouveau addin à votre application" directement dans Visual Studio
• Mise à disposition d'un modèle objet permettant d'utiliser des fonctionnalités de l'application à étendre depuis l'Addin
• Mise en place dans l'application à étendre d'un système permettant d'ajouter, d’initialiser, de supprimer et de communiquer avec des Addins de manière sécurisée.
VSTA permet donc de gérer des extensibilités, en utilisant des outils standards et familiers pour le développeur tout en proposant un système d'addin efficace et non intrusif.
Une fois l'introduction faite, la présentation s'est terminée par une démonstration de création de mise en place de système d'addin par dessus un NotePad WPF, de packaging du modèle de projet de celui-ci puis de création d'un addin avec celui-ci. Démonstration plutôt (trop) longue: au programme du code, des outils en ligne de commande, du code et des outils en ligne de commande.
La mise en place ne semble pas compliquée, mais nécessite juste un bon tutorial afin de maitriser les différentes lignes de commandes requises.
Pour aller plus loin:
• Blog équipe VSTA: http://blogs.msdn.com/vsta/
• Article de MSDN Mag: http://msdn.microsoft.com/msdnmag/issues/06/08/AddInPower/
• Visual Studio Extensibility Developer Center: http://msdn2.microsoft.com/en-us/vstudio/aa700819.aspx
• Visual Studio 2008 SDK: http://www.microsoft.com/downloads/details.aspx?FamilyID=D9000E2C-BD3F-4717-A181-723960814E16&displaylang=en
Pour du contenu en Français, j'ai cru comprendre qu'un certain bloggeur préparai un article sur le sujet :)
EDIT: retrouvez les autres comptes rendu de session Teched à cette adresse
James Lau - Lead Program Manager Microsoft
Session consacrée à l'extensibilité de Visual Studio 2008 avec les nouvelles opportunités de packaging de vos outils de développements personnalisés.
Comment créer son propre environnement de développement avec Visual Studio Shell?
Visual Studio 2008 insiste sur deux mode d'extensibilité n'ayant pas grand chose de commun:
- Visual Studio Tools for Applications (VSTA): permet de rendre vos applications extensibles et de mettre rapidement et facilement en place un système d'Addin
- Visual Studio 2008 Shell: permet d'utiliser Visual Studio 2008 comme environnement de développement personnalisés
Visual Studio 2008 Shell:
- Conteneur indépendant avec les bases d'un IDE: toolbox, surface de conception...
- Malgré le fait que cela s'appui dessus, visual Studio n'est pas un pré-requis sur la machine ou il sera déployé
- Aide à accélérer le développement
Deux modes:
- Intégrée à Visual Studio => Optimisé pour la création de langages de développement, vient se positionner dans Visual Studio comme un addin classique. Les différentes éditions de la gamme Visual Studio 2008 s'appuient ainsi sur VS Shell de manière intégrée.
- Isolée (indépendante) de Visual Studio => Utilisables pour des outils totalement spécifiques (fonctionnels, métier...), indépendant et ne nécessitant donc pas Visual Studio d'installé sur la machine (ne ciblant pas donc forcement un public de développeurs).
Comment cela marche: Ajout d'une DLL AppEnvStub.dll par dessus les binaires de Visual Studio afin de rendre disponibles trois actions: Start, Setup et Remove.
Pour créer une application s'appuyant sur Visual Studio Shell:
- Génération d'une base
- Ajout d'extensions: packages, templates, documentations
- Création d'un projet de déploiement
Démonstration d'un cas concret d'implémentation:
Utilisation d'un DSL dédié aux analystes depuis Visual Studio. L'application est fonctionnelle, mais le superflux de Visual Studio est de trop: les menus, les différentes fenêtres output, solution... Il sera donc intéressant d'alléger ce designer. Pour réaliser ceci, installation du SDK de Visual Studio, exécution de Visual Studio (en administrateur!) et utilisation du modèle de projet Visual Studio Shell Isolated. Ceci créé un projet en C++ capable de générer un Visual studio, il ne reste plus qu'a modifier le code afin d'alléger le menu et de désactiver les éléments inutiles (à l'aide de différents fichiers de configuration faisant référence à des clés de la base de registre).
Pré-requis:
- En développement VS + VS SDK
- Pour déployer: Votre application, vos blocs d'extensibilité (DSL, templates, addin...) et le VS Shell Runtime (qui contient les binaires de Visual Studio).
Mode de licence: Gratuitement redistribuable, juste quelques restrictions pour le mode isolé:
- ajout d’une fenêtre d'aide personnalisé
- ne doit pas enlever le logo visual studio présent au démarrage
- ne doit pas charger de packages MS
- ne dois pas modifier le comportement de packages VS
- il faut accepter l'EULA.
On pourra juste regretter que la démonstration et les explications se soit uniquement portés sur le C++ alors que Visual Studio permet également d'utiliser les langages managé (exemples du SDK uniquement en C#) via une couche managée qui interagit avec la couche Interop de Visual Studio.
Lien utile: Visual Studio 2008 SDK http://www.microsoft.com/downloads/details.aspx?FamilyID=D9000E2C-BD3F-4717-A181-723960814E16&displaylang=en
Merci a Julien pour avoir tapé ce résumé pour moi: je suis crevé!
Mark Seemann - Senior Consultat Microsoft Services
Une session consacrée à la création de Mocks, une des techniques avancées de tests unitaires, avec pour les exemples comme utilisation de Framework de test unitaire: MSTest.
Objectif de la session:
- Rappels sur l'intérêt des tests doubles
- Aide au choix de l'outil le plus adapté pour l'utilisation de Mocks
Rappel sur l'importance de la relation fonction à tester <=> dépendances: Dans un test unitaire, il est souhaitable de faire abstraction des dépendances (appels externes) de la fonction à tester. Le but d'un "test double" est de simuler / remplacer une dépendance pour pouvoir cibler uniquement l'unité testée.
Un rappel a aussi été fait sur l'importance de la clarté et de la simplicité des tests unitaires car ceux-ci peuvent servir de documentation pour une API en expliquant par l'exemple le fonctionnement de chaque méthode de celle-ci.
Concernant les tests doubles, il en existe plusieurs types:
• Dummies, fakes: remplacement d'un objet utilisé dans la méthode à tester par un objet qui ne sera jamais utilisé: juste pour permettre à la méthode de compiler et de s'exécuter
• Fakes: Remplace une fonctionnalité d'une dépendance par une implémentation différente
• Spies: permet de vérifier les appels fait a un composant externe en se mettant a sa place et en registrant ceux-ci
• Stubs: objet utilisé pour remplacer un composant réél et simuler les interactions avec celui-ci
• Mocks: Remplace un objet utilisé par le code a tester en simulant un comportement identique
• re-implémentation d'une dépendance complète avec éventuellement simplification
Pour la création de Mocks, il existe deux approches: soit une implémentation complète (manual mock), soit l'utilisation d'un Framework pour le générer automatiquement a l'exécution de l'application (dynamick mock).
Exemple de Dynamick Mock Librairies téléchargeables gratuitement sur internet
- Rhino Mocks: système d'enregistrement, type safe
- NMOck2: string-based.
Exemple d'implémentation avec NMock2:
Mockery mocks = new Mockery();
//création d'un mock pour remplacer l'objet d'accès aux données "IShopDataAccess"
IShopDataAccess dataAccess = mocks.NewMock<IShopDataAccess>();
//spécification du comportement attendu: Dans l'objet DataAccess la méthode "GetProductPrive" appelée avec l'argument "1234" doit renvoyer "10f".
Expect.Once.On(dataAccess).Method("GetProductPrive").with(1234).Will(Return.Value(10f));
//Appel de l'objet a tester avec le Mock en paramètre
Order o = new Order(dataAccess);
o.Lines.Add(1234).Quantity = 4;
decimal total = o.CalculateTotal();
//on vérifie que le Mock a bien été appelé comme attendu
mocks.VerifyAllExpectationsHaveBeenMet();
Pour aller plus loin:
• un article de Mark Seemann très complet sur les tests doubles dans MSN Mag: http://msdn.microsoft.com/msdnmag/issues/07/09/MockTesting/default.aspx
• Le livre xUnit test patteners: Refactoring Test code: http://www.amazon.fr/xUnit-Test-Patterns-Refactoring-Code/dp/0131495054/ref=pd_bbs_sr_1/402-5245909-8257750?ie=UTF8&s=english-books&qid=1194787748&sr=8-1
Daniel Moth - Developer and Platform Group, Microsoft
Une session au titre alléchant sur le papier car traitant des API .NET habituellement peu utilisées car spécifiques à Windows Vista.
Daniel a directement annoncé la couleur: cela ne sera pas une session sur le Framework 3.0 mais vraiment sur le développement Managed pour Windows Vista.
Windows Error Reporting
Nouvelle expérience utilisateur: après un crash, vista collecte des informations puis il est possible d'envoyer l'erreur mais aussi maintenant de demander à l'application de chercher automatiquement une solution.
Pour voir apparaitre la liste des problèmes, il est possible d'utiliser dans Vista l'application "Problem Reports et Solutions" pour afficher la liste de l'historique des problèmes et éventuellement des solutions lorsqu'elles sont présentes. Depuis cette application, tous les crashs sont répertoriés par application et il est possible de:
- Consulter le détail du rapport de problème
- Envoyer le rapport
- Consulter la solution
- Essayer de fixer automatiquement le problème
Une nouvelle API publique permet d’ajouter des fichiers sélectionnés (tel que le log de l'application) dans le rapport d'erreur et d'en créé un beaucoup plus personnalisé: utilisation de la librairie "wer.dll".
Restarts & Recovery APIs
Après un crash, il est possible de configurer l'application pour qu'elle redémarre automatiquement avec un argument spécifique pour notifier que l'exécution de celle-ci est due à un problème et éventuellement envoyer des informations sur la cause du crash au travers de cet argument.
L'appel Recover de l'API permet quand à lui de déclencher un bout de code spécifié permettant de tenter de réparer l'application en cas de crash.
Restart Manager
Il s'agit d'une API permettant d'arrêter de et redémarrer automatiquement une application en la remettant dans le même étant qu'avant son arrêt. Ceci permet par exemple d'avoir des programmes d'installation qui nécessitent l'arrêt d'une application pour fonctionner: celui-ci peut se faire automatiquement sans impact pour l'utilisateur grâce au restart manager qui permet de piloter le redémarrage d'autres applications (si celles-ci l'autorisent au travers de la restart API vu juste avant).
Preview Handlers
Alors la, une découverte de fonctionnalité pour moi: Windows Vista propose dans son explorateur un "Preview Pane", accessible via l'option layout / preview Pane. Celui-ci permet d'avoir un aperçut de l'élément (fichier, video, email...) sélectionné directement dans un panel de l'explorateur.
Il est possible de créer vos propres "Preview Handler" en utilisant une API spécifique (exemples d'implémentation disponibles dans MSDN magazine: le contenu d'un fichier CSV, un public token key, un pdf, le contenu d'un zip...). Une fois développé, pour l'activer dans Vista, il suffit ensuite de mettre sa DLL dans le GAC et de faire un Regasm.
User Account Control
Il est possible par programmation de faire une demande d'élévation de droits (et donc faire apparaitre la fenêtre de l'UAC) lorsqu'une application a besoin de droits administrateur (exemple pour tester: modifier l'event log): dans ce cas celle-ci s'arrête et redémarre avec un "runas".
Plus d'informations sur l'UAC: http://blogs.developpeur.org/tom/archive/2007/02/21/net-la-v2-du-document-vista-application-development-requirements-for-uac-est-disponible.aspx
En complément, Vista propose aussi des API pour ajouter des fenêtres de dialogues spécifiques, manipuler la SideBar, gérer la batterie, manipuler la recherche et mettre en place un SideShow.
En opposition à celle sur le développement pour Windows 2008, cette session fut plutôt une très bonne surprise de mon coté, car illustrée par un ensemble de démonstrations simples et efficaces.
Lien sur le blog de Daniel pour explications et démonstration de l'ensemble de la présentation: "Vista only features for the managed developer" http://www.danielmoth.com/Blog/2006/11/vista-only-features-for-managed.html
Brian Randell - Senior Consultant MCW Technologies
Martin Woodward - Lead architect Teamprise
Une des seules sessions que j'avais repérées dans mes flux RSS avant de venir au Teched. La semaine commence à être difficile, je me suis fait violence, je me suis levé, j'y suis allé et je n'ai vraiment, mais alors vraiment pas regretté!
Cette session est donc axée autour de Team Build / MSBuild et plus particulièrement les nombreuses évolutions apportées par la version 2008.
L'automatisation de Build n'est pas:
• Une utilisation massive de la touche F5
L'automatisation de Build c'est:
• L'extraction d'éléments dans un dépôt de sources
• L'assemblage de ceux-ci
• La validation de celui-ci
• L'audit du résultat
L'automatisation aide à se poser les questions:
• Nos sources créent-elle un produit?
• Sommes-nous dans les temps?
• Notre produit est il de bonne qualité?
Team Build 2008 est la réponse de Microsoft au besoin d'automatisation de build, le nom officiel du produit permettant de faire ceci est Visual Studio 2008 Team Foundation Server Build, celui-ci fait partit de la gamme Team System et vient complémenter Team Foundation Server (qui est requis).
Nouveautés apportées par la version 2008:
• Dans la définition d'une Build, il est maintenant possible de spécifier, via une interface graphique, au niveau du source control, un Workspace spécifiantl'ensemble des sources devant être prises en compte dans le process de Build (dans la version 2005, tout le team project était automatiquement extrait). Ceci permet d'optimiser le volume de sources extrait par le service de build lors de l'assemblage en ciblant uniquement celle utiles.
• Il est maintenant possible de prendre en compte plusieurs solutions (au sens visual studio du terme) dans une définition de Build
• Sur la partie test à exécuter, il n'est plus nécessaire de spécifier une liste de test (test list) pour définir les tests devant être joués après la Build: il est maintenant possible de demander directement au service de build de détecter et d'exécuter tout les tests présents dans une assembly sélectionnée
• Apparition de la notion de "Retention Policy": que faire des builds qui échouent, sont stoppées, sont réussit partiellement ou ont réussit: il est maintenant possible de spécifier que l'on souhaite garder la dernière, les supprimer, garder les n dernières.... Pratique pour garder un serveur de Build propre (surtout dans un contexte d'intégration continue ou chaque check-in génère une release et que l'espace disque du serveur est réduit). Il est aussi possible de spécifier explicitement (via un système de lock) sur un résultat de build que celui-ci doit être conservé et que les règles de nettoyage ne doivent pas le prendre en compte.
• Trigger et scheduled Build: possibilité de déclencher automatiquement le service de build: au checkin, des qu'il y'a eut un ou plusieurs checkin et que le serveur est prêt (avec la possibilité de dire de build au maximum 1 fois dans un intervalle de temps - 1 fois toutes les 10min par exemple) ou encore des jours spécifiques a une heure particulière
• Build Queuing: Les builds se mettent automatiquement en attente jusqu'a ce que le service de build ait terminé les traitements en court. Il est ainsi possible de prioriser certains types de Build (pour une release urgente qui ne peut attendre par exemple)
Compatibilité TFS 2005 / TFS 2008 vs Team explorer (client) 2005 / 2008: Team Explorer 2008 permet de gérer des Builds sur un serveur 2008 sans accès aux nouveautés de la même manière que Team Exporer 2005 offre la possibilité de se connecter a un serveur de Build 2005.
Les différentes étapes exécutées durant le processus de Build sont:
• Initialisation de la build depuis TFS
• Préparation de l'agent de build et génération d'un numéro de Build
• Synchronisation (récupération) des sources
• Compilation et analyse
• Exécution des tests (test list ou DLL)
• Mise à jour des Work Items impliqués par les sources compilées
• Calcul de la couverture de code
• Calcul du "code churn"
• Génération du rapport de build
• Copie de résultat dans le répertoire de livraison
• Publication des résultats dans TFS
• Levé d'un événement (service de notification) pour notifier que la Build est terminée
Fonctionnement de l'intégration continue dans TFS 2008:
• Un développeur fait un check in et créé un changeset
• Le service de gestion de sources lève un événement pour remonter le checkin au service de notification
• Le service de build est abonné à l'événement, analyse le changeset, et recherche la définition de Build y étant associé pour faire une demande d'exécution (mise en attente)
• L'agent de build reçoit un événement car une demande de build est en attente, récupère la définition, compile, et lève un événement au niveau du service de notification pour prévenir que le livrable est généré
• il est aussi possible de s'abonner aux événements de démarrage / fin de build dans une application interne: après la RTM de TFS 2008, un powertool sera disponible pour permettre, depuis Windows, d'obtenir en tray icone l'état d'un type de build (en court, réussit, échoué...)
Agents de build: Team Build 2008 peut être configuré pour plusieurs agents de Build (local, distant...) et il est donc possible lors de la définition de sélectionner celui souhaité. La communication avec l'agent de Build se fait maintenant en HTTP(s).
Personnalisation de définition de Build:
• Nécessite de check-out et de modifier le fichier de définition de la Build
• Possibilité d'écrire ses propres Tasks (action devant être exécutée avant / pendant / après le Build) en .NET en utilisant l'interface ITask
En conclusion, Team Build reste de loin la partie de TFS ayant subit le plus d'améliorations durant le passage de TFS 2005 vers TFS 2008. A lui seule une bonne raison de migrer vers la version 2008!
Carl Perry - Senior Program Manager Lead, Microsoft
Une session devant être normalement riche en nouveautés de mon coté car, au moment ou je pénètre dans la salle de conférence, je n'ai vraiment aucune idée de ce qu'est l'Entity Framework.
Rappels sur l'accès aux données avec ADO.NET 2.0: Création de connexion à une base de données, définition d'une commande en SQL (par exemple sur une jointure de deux tables) et exécution de celle-ci au travers d'un reader pour extraire les données jointes: modèle de manipulation et d'extraction de données extrêmement performant mais nécessitant de connaitre la base de données.
Positionnement de ADO.NET Entity Framework: manipulation d'objets (au sens .NET) plutôt que d'objets SQL.
ADO.NET 2.0 vs ADO.NET Entity Framework:
• Abstraction: Bas niveau sur schéma de la base vs schéma conceptuel plus haut niveau
• Langage de requêtage: requête entre "" vs LINQ
• Résultat de requête: Faiblement typé contre fortement typé
Vocabulaire:
• Entity Data Model (EDM): terme utilisé pour définir la description un schéma conceptuel. Modélise graphiquement les données que l'application veut voir (et non pas peut voir).
• Entities: Types distinct, simple ou complexes
• Relations: Mise en évidence des relations entre les types via une déclaration explicite.
L'entity Framework se positionne donc non par a coté, mais par dessus les providers d'accès aux données d'ADO.NET. Source de données => ADO.NET 2.0 Data Providers => EntityClientDataProvider (pour extraire les données) => Entity Framework Object Services (pour exposer les données sous forme d'object utilisables dans le code).
Première démonstration: utilisation de l'Entity Framework:
- Création d'une application ASP.NET
- Ajout d'un fichier de type "ADO.NET Entity Data Model" au projet
- Sélection d'une base de données cible
- Sélection des tables, vues et procédures stockées devant apparaitre dans le modèle
- Représentation, dans une sorte de "Class Diagram", des éléments (tables et vues) et des relations. Chaque entité contient des propriétés (mappées sur la structure de la table cible) et des éléments de navigation permettant par programmation de naviguer de relation en relation. Le diagramme est généré à partir du schéma de la base de données, mais celui-ci peut ne pas correspondre à la réalité, il est donc possible ensuite de redéfinir le modèle, les relations et le mapping, en ajoutant par exemple dans une entité des données issue d'une relation avec une autre table => ADO.NET Entity Data Model se charge automatiquement de générer la requête permettant de peupler l'entité.
Comment manipuler un Entity Data Model? Deux approches: LINQ ou Entity SQL (syntaxe SQL classique)
- LINQ to Entities: Manipulation des entités via LINQ, utile pour la validation de la syntaxe et intelissence
- Entity SQL : ajout de sémantique EDM au SQL, utile pour la création de requêtes dynamiques et la manipulation de procédures stockées. Les requêtes s'écrivent donc en SQL mais en interrogeant le modèle contenant les entités plutôt que directement la base.
Dans les deux cas, toutes les requêtes finissent vers la base sous la forme de requêtes SQL auto-générées.
Deuxième démonstration:
- Utilisation de LINQ to Entities pour paginer des données à afficher dans une GridView ASP.NET 2.0 (utilisation de LINQ classique)
- Utilisation de eSQL pour récupérer une liste d'utilisateurs filtrée: Object<Customer> query = aw.CreateQuery<Customer>("@SELECT VALUE c FROM .... WHERE ...."); avec la possibilité de paramètrera cette requête.
Mon point de vue final: une approche beaucoup plus intéressante et beaucoup plus flexible à l'abstraction de données que les actuels "TableDataAdapter" tout en bénéficiant de la puissance de LINQ pour une manipulation plus fine et plus performante. Une belle couche intermédiaire d'un point de vue conception entre LINQ et les sources de données SQL.
Pour aller plus loin: http://msdn2.microsoft.com/en-us/library/aa697427(vs.80).aspx
Don Smith - Product Manager Microsoft
Dennis Doomen - Team Lead Avina Solution
Olaf Conijn
Objectifs de la session:
• Comprendre ce qu'est une Software Factory
• Définir ce qu'il faut avoir pour en construire une
• Comment en construire une
Qu'est ce que c'est, concrètement:
- Un outil pour créer un type spécifique de projet
- Qui s'exécute dans Visual Studio
- A base de modèles, de designers, d'éditeurs et d'assistants
- Qui génère en général un produit en sortie
- Qui contient des exécutables, des fichiers, des éléments réutilisables...
Première démonstration de factory: Web Service Software Factory - permettant de modéliser des WebServices. Utilisation d'un designer pour définir un modèle. Implémentation de celui-ci de manière automatique directement depuis Visual Studio pour générer un squelette de solution avec une organisation logique de projet. Puis génération de code dans ces projets directement via des clicks droit depuis le modèle.
La vrai question: Combien de temps cela prend?
• Pour construire une factory, 2 à 3 fois plus de temps que pour construire le produit directement
• Le retour sur investissement n'apparait réellement qu'après l'implémentation d'au moins 5 produits
Dans quels cas faut-il créer une factory?
• Pour créer plusieurs instances d'un même produit
• Réutiliser des fonctionnalités d'un socle existant
• Imposer une architecture dans un projet: tous les projets démarrent du même modèle et de la même organisation
• Augmenter productivité et qualité de produit: gain de temps et structure du produit bien défini
• Nécessite moins d'expérience humaine pour créer le produit: les fondations sont solides et auto-générées sans nécessiter de compétences techniques avancées
Cela requiert cependant:
• Un domaine fonctionnel bien compris
• Une connaissance globale des librairies, framework et types d'implémentations existants (une vision très globale)
• Des personnes possédant à la fois des compétences métier, techniques et en construction de factory pour son écriture
L'investissement augmente avec la complexité de la factory (du plus faible au plus élevé):
- Une librairie de classe / framework
- Un template de solution ou de projet Visual Studio
- des déclenchements d'actions automatiques
- Un générateur intégré
Démonstration: Création d'un "Guidance Package". Création d'un projet contenant un ensemble de fichier puis transformation de celui-ci en modèle de projet en utilisation l'option "export template" de Visual Studio, le tout dans le but de pouvoir repartir de ce modèle de base sur chaque nouveau projet.
Quels outils utiliser:
• Pour l'ajout de fonctionnalités: GAX/GAT
• Code / Artifact Templates : Visual Studio Text editor
• Projet / solution Template : Visual Studio Templates
• Logical Application et System Design: VS Team Edition for Architects
D'un point de vue organisation et méthodologique, les différentes phases de créations d'une factory sont: Développement => Test sur un projet pilote (génération de produit avec la factory pour valider son efficacité et le résultat) => Planification de l'itération suivante et retour en phase de développement. Le tout de manière cyclique jusqu'a l’aboutissement de la factory et son déploiement. Une fois déployée, des nouveaux scénarios peuvent apparaitre nécessitant de recommencer le cycle de développement afin d'améliorer la factory.
Quels sont les critères qualificatifs d'une factory? :
• Abstraction: doit augmenter la productivité en limitant la redondance de travail difficile
• Utilisation: l'outil doit être utilisé, documentée et les développeurs doivent y être formés / sensibilisés
Dernière démonstration, utilisation des Domain Specific Language (DSL) tools dans le but d'écrire un générateur de DSL permettant lui même de générer du code!
Plus d'informations en Français sur tout ceci et notamment les DSL Tools: http://www.dslfactory.org (je pense qu'il devrait y avoir en ligne les Webcast des extensibiliy days, événement référant sur le sujet, très prochainement)
Bon, sur le coup, mon résumé est un peu confus, mais ce n'est pas un sujet que j'arrive facilement à rédiger (et la fatigue commence a bien se faire sentir a la fin de ce troisième jour), donc je vous prie de m’en excuser !
Dominick Baier - Security Consultant / thinktecture
Encore une session sur un sujet complètement différent: CardSpace. Pas une nouveauté en soit vu que CardSpace fait parti du Framework 3.0 et est disponible depuis Vista, mais j'avoue que l'idée d'avoir un retour d'expérience sur sa mise en place m'a plutôt attiré.
Pourquoi mettre en place CardSpace?
- Rendre le processus d'authentification plus simple via une simple selection de carte plutôt que par la saisie d'identifiants
- Minimiser le nombre de login / mot de passes utilisés sur internet en les regroupant dans une ou plusieurs cartes, stockée localement sur le poste client (pas de diffusion du mot de passe donc)
- Rendre les applications plus sécurisées en empêcher notamment le risque de fishing
Qu'il y'a t'il dans une carte CardSpace:
- Des données générées dynamiquement:
- Une clé publique : utilisée pour le chiffrage de la carte
- PPID - Private Personal Identifier: représente un identifiant de relation carte / site cible
- Des données saisies par l'utilisateur
- Donc pas d'identifiant / mot de passe stockés dans votre application ASP.NET 2.0, uniquement un identifiant unique représentant la carte
Intégration dans ASP.NET 2.0
- L'objectif est d'ajouter une balise <object> spécifique dans l'HTML généré (type="application/x-informationcard") dans laquelle sont spécifiés les éléments devant être renvoyés à l'application Web.
- Le navigateur Web utilisé doit ensuite repérer et interpréter cet objet, le compléter avec les informations requises et le renvoyer
- Pour faciliter cette implémentation, il est possible d'utiliser le contrôle ASP.NET "InfoCardSelector" permettant de spécifier automatiquement au client les données devant être transmises
Les informations de l'utilisateur sont donc stockées dans la carte et transmises à la création (association) du compte utilisateur. Il faut donc faire attention de bien synchroniser les informations stockées sur le site (adresse postale par exemple), a chaque fois que l'utilisateur se connecte avec sa carte.
Exemple de schéma de base de données pour stocker les identifiants:
- Une table "Users" contenant UserID / FirstName / LastName / EmailAdresse => un utilisateur du site est uniquement
- Une table de relation 0 to n "information Cards" contenant UniqueID / UserID / IssuerID => un utilisateur peut avoir de 1 a n cartes (une carte pas machine utilisée par exemple, usage perso et pro)
Dans le cas ou un utilisateur perd sa carte, il doit lui être rendu possible de générer un mot de passe pour se connecter de manière classique à son compte pour refaire une association de carte.
Dans tout les cas, pour une utilisation de CardSpace sur un site Web, il est conseillé de garder en parallèle un mode d'authentification classique par formulaire, pour permettre la re-association de carte en cas de perte de celle-ci ou pour le besoin d'association de carte sur une autre machine.
Bon, j'ai largement été rassuré par le niveau de faisabilité d'intégration de CardSpace sur un site ASP.NET 2.0 existant et utilisant déja une authentification classique. Ma première action après le Teched sera donc de me lancer dans une implémentation concrète de CardSpace.
Quelques liens pour aller plus loin:
- Préparer une machine de développement pour CardSpace: http://blog.couzy.com/PermaLink,guid,4092feab-d315-4d00-b19a-7cd52c47aafe.aspx
- Exemple d'implémentation: http://www.netfxfactory.org/blogs/actualites/archive/2007/05/15/windows-cardspace-cartographions-nos-identit-s.aspx
Roy Osherove - SELA Group www.ISerializable.com (blog)
Retour a une activité plus sérieuse. Quelle fut ma surprise en rentrant dans la salle que de voir que le speaker de cette session était Roy Osherove, déjà vu sur une session sur l'agilité lundi (en fait j'ai d'abord vu sa guitare en rentrant dans la salle, en place au milieu de la salle pour sa chanson finale).
Cette session s'est déroulée sur un modèle interactif, sans slides et sans contenu prédéfinit (la première que je vois ici) - approche originale et courageuse devant une salle pleine à craquer devant contenir au moins 300 personnes. Roy a demandé au public de proposer des thèmes autour des tests unitaires et mis ensuite en place un système de vote pour définir le contenu à prioriser.
Voici les thèmes proposés tour à tour par les participants à la session:
- NUnit Vs MBunit Vs MSTest 2008
- Multithreading related tests
- State Based Vs. Interaction Based testing
- Mocks Objects tips and tricks
- When to refactor design for testability
- TypeMock - good or bad
- Web testing in unit tests
- Legacy code testing
- What does TDD mean - how to do it?
- UI Testing
- Unit Vs. Integration testing
- Distributed test running
- LINQ Mocking
- Testing data layers - DB
Les (300) participants ont ensuite voté à main levé pour sélectionner les sujets a prioriser (avec une limite de 5 votes chacun), le tout fait dans un contexte décontracté avec des réponses pleines d'humour.
Voici les réponses de Roy:
UI Testing: Le rôle du développeur est de séparer au maximum la logique d'affichage de la logique métier en utilisant un modèle MVC si possible, rendant le maximum de composants testable via tests unitaires. Le test d'interface graphique a proprement parlé, doit se faire par les humains.
Testing Data Layers: Faut il tester la couche Data? La couche métier l'utilise, donc on pourrai se contenter de tester celle-ci. Mais dans certains cas, il existe bel et bien de la logique dans une base de données: relation, trigger, proc stocks... donc comment valider tout ceci. Exemple: utilisation d'une classe faisant des insertions dans une base de données. A chaque exécution du test, la base de données est polluée, il est donc nécessaire de supprimer les données insérées après. Ceci peut se faire en encapsulant le test dans une transaction .NET, en utilisant un RollBack en fin de test (attention cependant, avec l'utilisation d'entiers auto-incrémentés, le rollback ne decrémente pas l'identifiant, il est nécessaire d'écrire un peu de SQL pour ceci dans la phase de nétoyage du code).
Mocking: Comment tester des objets ayant des dépendances fortes et contraignantes avec d'autres objects en ignorant / simulant ces dépendances - en remplacant l'objet dépendant par un Mock object (exemple fait avec un "Fake object"). J'en reparlerai plus en détail demain durant la session consacrée à ce sujet. Il est possible d'utiliser un Mock dynamique (ex: Nunit.DynamicMock ou RhinoMock) pour faciliter la création de mock: créé automatiquement par le runtime lors de l'exécution du test, nul besoin d'implémentation concrète.
Politique de nommage des tests: Il est important d'utiliser des noms de méthode de test les plus explicites possibles contenant les information MethodeATester_DansQuelContexte_QuAttendre(). Ex: DoSomelogic_NullMsg_ThrowsException()
Test sur du multithreading: Exemple avec l'utilisation d'une librairie TrheadTester développé par Roy (http://weblogs.asp.net/rosherove/archive/2007/06/22/multi-threaded-unit-tests-with-osherove-threadtester.aspx)
NUnit Vs MBunit Vs MSTest: Pour Roy, Aller de NUnit vers MBUnit est très simple et naturel. MBunit est le framework le plus facile a étendre. MSTest est bien pour une utilisation similaire a NUnit (mais uniquement la version 2008, il considère la version 2005 comme n'étant pas assez performante). Il est cependant délicat de passer de MBunit vers MSTest de part un manque d'attributs présents dans MBUnit dont on prend rapidement gout.
La présentation s'est ensuite bien sur terminée par une chanson accompagnée à la guitarre. Avec ce coup-ci comme thématique "le premier test du développeur".
Jaser Elmorsy - CEO BlueBridge TEchnologies
Pour commencer cette troisième journée de conférences, une session sur un sujet encore complètement différent par rapport à ceux vu précédemment me permettant de répondre à la question: comment pouvoir intégrer simplement (et rapidement) un système de messagerie instantanée dans des applications d'entreprise.
Terminologie: CWS - Microsoft Office Communicator Web Access
Présentation de Microsoft Office Communicator Web Access, permettant de se connecter au serveur de messagerie instantannée Communicator directement depuis un navigateur Web. A noter que malgré le fait que cela soit développé en technologie Web (protocole déconnecté), les temps de réponses sur la reception de message et la notification de status sont quasiment instantanés (comme si il s'appuyait sur un protocole connecté).
l'UC Ajax SDK, utilisé par Microsoft pour écrire leur client Web, est rendu disponible pour les développeurs. Celui-ci permet de faciliter la création de client de messagerie Web basés sur Communicator de manière totalement personnalisée. Ceci offre des scénarios d'intégration dans vos applications Web d'interfaces de communication avec le serveur de dialogue: envoie de messages, notification du status de présence, le tout de manière indépendante de la plateforme (java, .net, peut importe).
L'échange de messages entre votre application et le serveur CWS se fait via des envoie de données XML sur HTTPS. Pour obtenir des temps de réponse rapide, la communication entre le client et CWS se fait via "open get": le client ouvre une connection, envoie des requêtes "GET" de manière asynchrone au serveur et le serveur utilise ces requêtes pour répondre si un message doit être renvoyé au client (a default de message, un timeout a lieu et le client relance des requêtes pour permettre au serveur de répondre).
Pour implémenter un client, il suffit ensuite d'échanger des messages avec le serveur, avec un certain ordre:
- Login: récupération d'un ticket d'authentification
- Initiate Session pour initialiser une nouvelle session sur le serveur
- Utilisation des messages de presence / collaboration sur toute la durée de la session. Pour optimiser le nombre de requêtes, un message peut contenir un ensemble illimité d'événements (informations), tels que par exemple la liste des utilisateurs complète, le changement de status d'une personne, le besoin de création d'une conversation et l'envoie d'un message dans une autre conversation...
- Terminate Session
Nous avons ensuite eut droit à une démonstration d'implémentation complète permettant de mettre concrètement en avant les données échangées entre le client et le serveur Communicator.
En résumé pour conclure:
- CWA permet de mettre en place "Unified Communication" quelque soit le navigateur et quelque soit la plateforme
- CWA est construit à partir de l'UC AJAX SDK
- L'UC AJAX SDK permet d'intégrer des fonctionnalités de CWA dans vos applications sans aucun besoin d'installation
- Le modèle "Open Get" s'appuyant sur XML par dessus HTTP facilite les temps de réponse
Téléchargement du Unified Communication SDK: http://www.microsoft.com/downloads/details.aspx?FamilyID=d5a36cc7-9b94-4082-ab55-22feffce6b80&displaylang=en (contient documentation et exemple)
Justin Smith et Matt Winkler - Technical Evangelists
Retour à mes amours avec une session assez poussée sur Workflow Foundation axée sur la principale nouveauté y étant apporté par la version 3.5 du Framework .NET : la possibilité de hoster, très facilement, un Workflow dans un service WCF.
Qu'est ce qu'on Workflow?: l'organisation d'un travail (ensemble d'éléments s'enchainant) représentant un processus métier ou une logique applicative.
A noter que Workflow Foundation est disponible depuis Novembre 2006 en temps qu'element de Windows Vista (Framework 3.0).
Qu'est ce qu'un service?: une fonctionnalité exposée via un système d'échange de messages structuré, décomposé en:
- Message Exchange Patterns (MEPs) DataGram, Request-Reply, Duplex...
- Data Formats: SOAP, JSON, Plain Old XML (POX)...
- Transports: HTTP, TCP/IP, Nameds Pipes, MSMQ...
- Architectural Styles / Protocols: WS-*, REST...
L'intérêt de WCF est de proposer un modèle de développement unique quelque soit les choix sélectionnés dans la liste précédente, tout en ajoutant des fonctionnalités de gestion (Trace, log, gestionde threads, protection DoS...). WCF est apparut dans le Framework .NET 3.0 et est amélioré dans la version 3.5.
Un service WCF est composé de trois blocs:
- Adress, binding, contract, définis dans un fichier XML pour exprimer la manière de communiquer (avec qui, comment)
- Service Contract Definition, interface en .NET, pour définir les fonctionnalités devant être exposés
- Service Type, implémentation du contrat en .NET
Retour clients sur .NET 3.0:
- Les services WCF nécessitent une couche de persistance robuste
- Il est intéressant d'exposer un Workflow en temps que service WCF plutôt qu'en temps que Webservice.
En .NET 3.0, il est possible d'héberger un workflow dans un service WCF mais cela nécessite une double implémentation de services client <=WCF=> hôte <=WF=> instances de workflow. (voir WebCast techdays) Toutefois, si on compare l'architecture de Workflow en temps que service à celle d'un service WCF, on peut constater qu'un service WF n'est rien d'autre qu'un service WCF avec quelques éléments supplémentaires. Dans ce cas, pourquoi ne pas grouper le service WCF nécessaire pour la communication client / hôte et le service WF nécessaire à la communication WF Runtime / instances dans un seul et seul service? : C'est ce que propose .NET 3.5 client <=WCF+WF=> instances de workflow.
Pour permettre ceci, de nouveaux éléments sont apparut dans Workflow Fondation (en se basant sur l'extensibilité de celui-ci):
- Deux activités: "SendActivity" et "ReceiveActivity"
- Un ContextBindingElement permettant de manipuler le contenu des messages
- L'accès a de nouveaux comportements : WorkflowRuntimeBehavior, PersistenceProviderBehavior, DurableServiceAttribute, DurableOperationAttributes
- Un nouveau service de hosting, pour hoster le runtime en temps que service
Ceci offre deux nouvelles approches d'utilisation de WCF et de WF:
- Implémentation de service WCF en temps que Workflow WF
- Hebérgement de Workflow WF en temps que service WCF
Pour aller un exemple, en Français, Xavier Vanneste a réalisé il y'a quelques temps un Webcast sur l'exposition d'un WF en temps que service WCF: http://www.netfxfactory.org/blogs/video___la_demande/archive/2007/09/22/publication-d-un-workflow-en-tant-que-web-service-ou-en-tant-que-wcf.aspx
Sans hésiter, la session que j'ai le plus apprécié depuis le début du TechEd.
Luke Hoban - Program Manager Microsoft
Grosse session apparemment très attendu au vu du remplissage de la salle (l'auditorium, la plus grosse salle ou s'est déja auparavant déroulé le Keynote) pour cette session consacrée aux principales nouveautés de C# 3.0. (enfin du code, du code et du code et rien que du code présenté de manière très fluide!)
Les principaux axes de conception de C# 3.0:
- Amélioration de C# 2
- L'apparition du "Language Integrated Query" (LINQ)
- 100% compatible avec les versions précédentes
Une fois ces concepts énumérés, Luke a enchainé directement par une démonstration d'implémentation en parlant d'une classe vide pour mettre en évidence les nouveautés:
- "Auto-implemented properties": Nouvelle syntaxe pour les accesseurs : public string CustomerID { get; set; }, en lecture seule: public string CustomerID { get; private set; }
- "Object Initializers": Initialisation des valeurs des propriétés d'un objet : new Customer() { prop1 = 1, prop2 = n...}.
- "Collection Initializers": Utilisation de la même syntaxe pour ajouter des objets à une collection générique lors de sa construction ou encore a un Dictionnary<n, m>
- Inférence de Type: utilisation du mot clé "var" pour masquer un type déductible automatiquement d'une implémentation
- "Query Expressions": utilisation d'une requête C# pour interroger une collection
- "Anonymous Types": type généré de manière anonyme directement par le compilateur en fonction d'un ensemble de propriétés
Retour ensuite aux slides pour présenter LINQ et ses différentes briques: to Objects, To DataSet, to SQL, to Entities, to XML.
Suite de la démonstration avec un exemple de re-implémentation de LINQ to Object en utilisant les "Lambda Expressions", la généricité et en introduisant les "extension methods".
Il existe beaucoup de contenu sur ce sujet, je ne vais donc pas m'étaler ici à le décrire mais plutôt profiter pleinement de la démonstration.
Quelques liens:
Les 10 derniers blogs postés
-
Un outil pour réaliser des animations WPF basées sur des équations de Bézier par
Perspective le il y a 3 heures et 1 minutes
-
Sandcastle et CodePlex : le verdict par
CoqBlog le il y a 3 heures et 52 minutes
-
Webcasts sur le Parallel Framework disponibles par
Matthieu MEZIL le il y a 7 heures et 20 minutes
-
[Silverlight] - Comprendre et Débuter avec Silverlight par
Danuz le il y a 12 heures et 5 minutes
-
SharePoint : Nouvel article sur l'exportation et Importation de sites SharePoint par
Blog Technique de Romelard Fabrice le il y a 23 heures et 46 minutes
-
ImagineCup 2008 Final in Paris: Day 1 par
Richard Clark le 07-03-2008, 22:48
-
PowerShell : Comment utiliser un ENUM .NET dan