Il y a un peu près un an j’écrivais sur mon blog trois articles sur l’extensibilité de Visual Studio 2008 :

• Part 1 : Comment étendre Microsoft Visual Studio

• Part 2 : créez vos fenêtres d’outils avec CreateToolWindow2 !

• Part 3 : Quelques interactions avec Visual Studio

Quelques jours après je poursuivez sur une introduction à MEF : Managed Extensibility Framework.

Le rapport ? Et bien mélangez les deux et vous aurez le nouveau modèle d’extensibilité de Visual Studio 2010 En ajoutant aussi que le nouvel éditeur de code en WPF (où l’on appréciera grandement le Zoom-In/Out lors de présentation), nous apporte des tas de possibilité en matière d’extension.

Jugez par vous même! Aurait-on pu avoir ce genre de comportement dans les versions antérieures ?

Un petit “add-in” qui remplace les chaines de caractères “wygwam” et “microsoft” par leurs logos respectifs ! Oui je sais cet add-in est inutile mais il montre bien les possibilités apportés “je fais ce que je veux où je veux…. Et en WPF”

Un petit article de présentation arrivera prochainement, en attendant retour en mode préparation des TechDays

Retrouvez-moi en compagnie de Gregory Renard, le 25 janvier à Mons et le 26 janvier à Liège à l’occasion du Azure Roadshow.

Quatre heures de conférence pour une prise en main technique de Windows Azure et SQL Azure. Durant la session nous parcourons :

• Le concept du cloud computing
• Le développement sur Windows Azure (Azure Compute)
• Le stockage sur Windows Azure (Azure Storage)
• L’exploration d’SQL Azure

Pour participer à cette session les pré-requis sont :

• être un développeur .NET et utiliser Microsoft Visual Studio 2008 SP1 ou Visual Studio 2010 Beta 2
• Venir avec son laptop
• Avoir préalablement installé le SDK de Windows Azure
• Plus d’info : http://www.microsoft.com/downloads/details.aspx?familyid=6967FF37-813E-47C7-B987-889124B43ABD&displaylang=en

Azure Roadshow – MIC, Mons
lundi 25 janvier 2010 9:30 – lundi 25 janvier 2010 13:00
Microsoft Innovation Center – MIC
Boulevard Initialis 1
Mons Belgique
Inscription : http://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032438248&Culture=fr-BE

Azure Roadshow – Technifutur , Liège 
mardi 26 janvier 2010 13:30 – mardi 26 janvier 2010 17:00
Technifutur – Liège Science Park
Rue du Bois Saint-Jean, 15/17 Seraing 4102
Liège Belgique
Inscription : http://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032438250&Culture=fr-BE

La disponibilité de la Beta 2 de Visual Studio 2010 et du .NET Framework 4.0 a été annoncé par Jason Zander, General Manager de Visual Studio ce lundi (19/10/2009) suivi de l’annonce de Scott Guthrie, General Manager de la division .Net chez MS Corp que j’ai eu la chance de rencontrer en Mars dernier à l’occasion du MIX09 à Las Vegas.

Parcourons ensemble ces nouvelles versions !

Visual Studio 2010

Après une 1ère CTP délivrée à Noël dernier qui nous a permis de découvrir les nouvelles possibilités du .NET 4.0 et une Beta 1 en milieu d’année, la Beta 2 diffusée en début de semaine est arrivée à maturation avec l’annonce d’une licence “Go-Live” pour le framework .NET 4.0 et Visual Studio 2010 !

Go-live signifie que vous avez le “GO” de Microsoft pour démarrer des projets de production dessus en vous garantissant un support sur ces versions ! La version finale de ces deux produits étant fixé pour le 22 Mars 2010 (surement à l’occasion du MIX 2010 ?).

L’arrivé de cette version 2010 (10) de Visual Studio fait aussi le ménage dans les nombreuses éditions des versions antérieures. Désormais il n’y aura plus que trois éditions en plus de la gamme “Express” gratuite :

• Visual Studio Express
• Visual Studio 2010 Professional avec MSDN
• Visual Studio 2010 Premium avec MSDN :
• Visual Studio 2010 Ultimate avec MSDN

A ce sujet je vous recommande la lecture de l’article de Christopher Maneu sur son blog : http://blog.christophermaneu.fr/2009/10/vs-2010-le-point-sur-les-versions/

Visual Studio 2008 / .NET 3.5 <> Visual Studio 2010 / .NET 4.0 “side-by-side” ! N’avez plus peur, l’environnement VS2010/NET4 est parfaitement compatible avec l’environnement VS08/NET35 sur la même machine ! Pas de risque de perturbation, vous pouvez comme moi, installer ce nouvel environnement en beta 2 sur votre poste tout en continuant vos développements sous VS2008. De plus avec la License “Go-Live”, vous pouvez y aller :=)

Pour les téléchargements c’est ici : http://msdn.microsoft.com/en-us/vstudio/dd582936.aspx

Installation

Après récupération de l’ISO, vous pourrez l’installer comme à votre habitude,

Vous noterez une erreur à la fin de l’installeur en ce qui concerne le SDK de Silverlight 3.0 ! N’en tenez pas compte

Et en prime, une nouvelle icone pour cette nouvelle version !

Premier lancement

Nouvelle icone et nouveau ”Splash Screen” :

… et nouvelle “Start Page” qui a encore évoluée par rapport à la CTP et Beta 1 :

Vous trouverez aussi de nouveau “Project template” en rapport avec Sharepoint 2007/2010, Office 2010, F#, Silverlight 3.0 et Windows Azure* par défaut.

En ce qui concerne le “project template” pour les services Azure il faudra patienter jusqu’en Novembre pour la disponibilité des tools Azure pour VS 2010. Actuellement, la création d’un projet Azure sous VS 2010 vous ouvrira la page suivante : http://blogs.msdn.com/jnak/archive/2009/10/18/windows-azure-tools-and-visual-studio-2010.aspx

Les nouveautés

Editeur de code et designers

Le look & feel de l’éditeur de code et des designer a un peu évolué par rapport aux versions précédentes avec notamment un rendu WPF permettant par exemple de pouvoir zoomer très facilement avec la molette de la souris tout en appuyant sur la touche “Control”. Cela va être très (très .. très) pratique pour les présentations publiques !

Online Template & Recent Project

Fonctionnalité bête mais qui m’a beaucoup plus, la possibilité de “Pin”(ner) un projet dans la liste des projets récents à la Windows Seven permettant d’avoir ses projets principaux à porté de main.

Dans la création de nouveau projet, nous avons la possibilité de lister des “Project template” en ligne, notamment pour accéder à des Starter Kits

Multi-targeting

Cette fonctionnalité a fait son apparition dans Visual Studio 2008 pour nous permettre de sélectionner le framework de destination de notre application (2.0, 3.0 ou 3.5). Etant donné que ces différentes versions du framework exploité la même CLR (qui n’a pas bougé depuis la 2.0), le multi-targeting de VS2008 s’occupé de filtrer les assemblies disponibles dans le Framework choisi. Mais dans certains cas, l’IntelliSense montrait des membres et/ou types des versions supérieures ce qui pouvait engendrer l’utilisation de méthodes du 3.0 ou 3.5 dans un projet 2.0 !

Sous Visual Studio 2010, le multi-targeting a été profondément revu avec ce qu’ils ont appelé les “reference assemblies” qui contiennent les méta données des assemblies d’un framework donné (en quelque sorte la cartographie des assemblies d’un framework).

Grace à cela, les “Property grid” des designers, le profiler, compilateur, Object browser, et tout ce qu’il se trouve dans VS010 se basent sur ces “reference assemblies” pour ne refléter que les types et membres du framework cible sélectionné.

Multi-Monitor

En tant qu’adapte du multi-moniteur, j’ai l’habitude de travailler avec deux écrans en mode étendu sous mon Windows Seven au travail comme à la maison ! J’avoue avoir déjà été gâté lors de l’arrivé de Windows Seven par le “Windows+P” permettant de sélectionner très rapidement et simplement le mode d’affichage.

Avec Visual Studio 2010 vous avez la possibilité de “sortir” vos documents et autres fenêtres de votre Visual Studio comme une fenêtre Windows pour la placer à l’endroit que vous voulez, sur l’écran que vous voulez.

Je peux donc exploiter au mieux mes écrans en plaçant par exemple mon designer WPF sur l’un des écrans pendant que j’édite son code source sur le deuxième :

Navigate To

Nommé initialement “Quick Search”, le “Navigate To” permet de rechercher facilement des symboles (variables, méthodes, classes, types, etc…) dans votre solution. (A l’inverse du “Search” qui recherche du texte brut dans des fichiers !).

Call Hierarchy

Cette fonctionnalité fort pratique nous permet d’avoir un affichage de la hiérarchie des appels sur une méthode.

Highlighted reference

Cette fonctionnalité permet de surligner dans mon code toutes les références d’une variable ou paramètres dans l’éditeur de code ! Assez pratique pour voir d’un seul coup d’œil où votre paramètre/variable est utilisé !

Parallel Programming and Debugging

Avec l’arrivé de Parallel Fx dans le .NET 4.0, VS2010 est doté d’outils de debugging permettant la visualisation et le débogage de chaque thread.

Dependency Graph

Permet de construire des graphs à partir du code source et/ou assemblies de votre solution pour représenter les différentes relations par assembly, namespace, classe ou manière personnalisée en spécifiant ce que l’on veut y voir et avec quel filtre. 

Les Diagrams

On y trouve un nouveau designer permettant de concevoir deux types de diagrammes : les “Layer Diagram” (architecture logique qui nous permettent d’organiser nos classes, namespaces, fichier de code, projets de notre solution, …) et les “UML Diagram” que l’on ne présentent plus.

Architecture Explorer

Cette nouvelle fenêtre nous permet de parcourir les relations dans notre code.

Et bien d’autre…

• Nouvelle version de TFS 2010, le serveur de contrôle de code source et de son client dans VS2010
• Un nouveau profiler de performance
• Nouveau outils à destination de testeur (Microsoft Test and Lab Manager entre autre)
• Nouveau designer pour les Workflows
• Un explorer pour Sharepoint
• Le “Code Optimized Web Development Profile” : un profile sans le designer web qui permet d’éditer le code source directement
• De nouveaux snippets
• …

.NET framework 4.0

Traiter du nouveau framework 4.0 dans son ensemble serait chose impossible dans un seul article tant les nouveautés sont importantes. Tentons d’en donner un petit aperçu.

Un nouveau moteur d’exécution : la CLR 4.0

Le framework 4.0 embarque un nouveau moteur d’exécution, la CLR 4.0 qui n’avait pas évolué depuis la version 2.0 en 2005. Rappelez-vous que le framework 3.0 puis 3.5 n’ont apporté que de nouvelles assemblies (comme WCF, WF, WPF, Linq, Data Service, etc…) mais tout cela reposant sur la CLR 2.0.

Avec ce nouveau framework la CLR à dû évoluer pour améliorer le support du multi-coeur, du garbage collector et des langages dynamiques (DLR).

Nouveau langages : C# 4.0 et VB 2010

Vous trouverez une série sur les nouveautés de VB 2010 sur le blog de Redo : http://blogs.developpeur.org/redo/archive/2009/02/10/nouveaut-s-de-visual-basic-2010-vb10-le-livre-blanc-recueil-de-blog.aspx

Concernant C# 4.0, nous pouvons citer entre autre :

• Les types “dynamic”
• La co- et contra- variance sur les collections
• Les paramètres nommées et optionnels
• L’amélioration de l’interopérabilité COM
• …

ADO.NET 4.0

Englobant :

• La beta 2  de Entity Framwork 4
• La beta 2 de ADO.NET Data Service 4 (ex Astoria)
• Lire : http://bit.ly/3zWNB1

ASP.NET 4.0

• Nouveaux contrôles pour les graphiques
• Nouveau framework pour ASP.NET Ajax 4.0
• ASP.NET MVC 2
• L’URL Routing pour Web Forms

WPF 4.0

• Support du multi-touch et extensibilité de la taskbar pour Windows Seven
• SDK de Surface 2.0
• Nouveaux contrôles (dont le Rubbon)
• Amélioration des performances, stabilité, ..

WCF & WF 4.0

• WF : Nouvelles Activities (lire http://bit.ly/12Htlb)
• WCF : Service de découverte, support du REST, service de routing

Et bien d’autre

• ParallelFx : Nouvelle API pour simplifier le développement parallèle comme TPL (Task Parrallel Library) ou PLINQ (Parrallel LINQ)
• MEF : Managed Extensibility Framework dont j’ai traité un article à ce sujet en début d’année

Et avant de finir, quelques liens :

• .NET Framework 4.0 Beta 2 (redistribuable) : http://www.microsoft.com/downloads/details.aspx?FamilyID=ded875c8-fe5e-4cc9-b973-2171b61fe982&displaylang=en
• Liste complètes des nouveautés de VS2010 : http://msdn.microsoft.com/en-us/library/bb385832(VS.100).aspx
• Annonce de Scott Gu : http://weblogs.asp.net/scottgu/archive/2009/10/19/vs-2010-and-net-4-0-beta-2.aspx
• Annonce de Jason Zander : http://blogs.msdn.com/jasonz/archive/2009/10/19/announcing-vs2010-net-framework-beta-2.aspx
• Site MSDN pour VS2010/.NET4 (Ressources et téléchargements) : http://msdn.microsoft.com/en-us/vstudio/dd582936.aspx
• Téléchargement direct de Visual Studio 2010 Ultimate Beta 2 au format ISO : http://www.microsoft.com/downloads/details.aspx?FamilyID=dc333ac8-596d-41e3-ba6c-84264e761b81&displaylang=en

Depuis le temps que je devais publier cet article resté près de deux mois dans mes brouillons, voila qui est fait !

Vous vous en souvenez peut être en début d’année de la sortie de MOB : Mesh Object Browser, une application WinForm fort bien utile pour les développeurs et ceux voulant comprendre le modèle de ressource du Live Framework.

Le Live Framework que je vous ai présenté dans mon post consacré à la nouvelle CTP d’Avril 2009 est, je me cite, "une API permettant d’unifier l’accès aux services Live et en particulier au “Live Operating Environment“".

Le Live Operating Environment (LOE) est en quelque sorte votre ordinateur virtuel hébergé sur le Cloud Azure dans ce que l’on appelle le Live Desktop où vous retrouverez vos applications et données partageable avec n’importe qui et cela accessible depuis n’importe quel de vos devices (ordinateurs, laptop, smartphone, web,….) par des mécanismes de synchronisation assurant notamment le fonctionnement en mode déconnecté.

Votre Live Operating Environment est exposé au travers d’un service REST sur le protocole standard du Web qu’est le HTTP. Le format de retour se précise avec le champ "Accept" de l’entête HTTP de votre requête. Au choix :

• ATOM
• JSON
• POX
• RSS

Vous l’aurez compris, votre Live Operating Environment n’est pas fermé aux technologies Microsoft : n’importe quel langage ou plateforme sachant créer une requête HTTP et parser du XML (ou JSON) peut accéder et interagir avec notre LOE. Au travers du "Live Framework SDK", Microsoft propose trois API simplifiant l’accès au LOE : une pour .NET, une autre pour Silverlight et une dernière pour Javascript ! Vous trouverez des exemples d utilisation du LOE, notamment avec d’autre langage comme PHP ou IronPython, sur le blog de l’equipe LiveFx.

Le Resource Model

Une fois connecté à votre LOE vous pourrez accéder à votre "Resource Model" (modèle de ressource) que forme vos données et applications.

Le Resource Model est le modèle de donnée de votre LOE. Il contient les ressources concrètes (type) et ses relations. Tout dans le Live Framework est exposé comme une ressource (application, donnée, notification, contact, profile, membres, etc…). Chacune de ces ressources disposes d’une URI fixe, d’un nom, d’un auteur, date de modification, etc…

L’avantage de ce découpage LOE <-> Resource Model est qu’il n’y a pas de lien fort entre le service responsable d’exposer en REST des collections de LiveItem et ce qu’on va réellement y stocker dans ces LiveItem que ce soit des contacts, des applications, des fichiers ou quoi que ce soit !

Aujourd’hui le Resource Model proposé dans le Live Framework est celui ci :

On y retrouve l’accès à notre Mesh, nos contacts et notre profile. Dans notre Mesh nous pouvons retrouver nos Devices, Applications, News et aussi nos MeshObject.

Chaque MeshObject contient une collection de Feed, des members pour la notion de partage, des news, des mappings pour la notion de synchronisation entre les Devices. Et c’est dans les DataFeed que nous retrouverons nos DataEntries qui matérialises nos entités dans notre LOE (par exemple un fichier dans Mesh est un DataEntries de type File d’un DataFeed de type LiveMeshFiles d’un MeshObject de type LiveMeshFolder).

Comment parcourir votre Resource Model ?

La première question que je me suis posé peu après avoir suivi les webcasts des sessions de la PDC en Octobre 2008 qui présentait le Live Framework était : comment parcourir notre Resource Model ?

Pour comprendre son fonctionnement comme pour développer on a besoin de savoir ce qu’il y a dedans, un peu comme on ouvre son SQL Studio Management ou phpMyAdmin pour explorer les tables, relations entre ces tables et données qu’elles contiennent.

Le Live Framework SDK offre un et un seul outil nommé le "Live Framework Resource Browser". Cet outil est ni plus ni moins qu’un browser web adapté pour la navigation du service REST "on the cloud" (Live Desktop) ou "local" (Local Desktop) du LiveFX. En effet ce browser à la particularité de  :

• Activer les liens dans les flux pour une navigation facile
• Formater les flux JSON
• Permettre de sélectionner son format de sortie (JSON/POX/RSS/ATOM)
• Éditer les requêtes HTTP

Cet outil bien que fort utile est limité en terme de recherche dans le Resource Model et de manipulation des LiveItem (création, édition et suppression). De plus en terme de visualisation, bien qu’un ordinateur n’aura pas de mal à lire des centaines de milliers de lignes de code (RSS, ATOM ou JSON), pour un humain c’est bien moins rapide, vite noyé dans la verbosité du langage et informations peu pertinentes !!!

C’est de là qu’est né, chez Wygwam, le besoin de disposer d’un outil permettant une représentation graphique du Resource Model de notre Live Operating Environment.

1er projet MOB : Mesh Object Browser

Développé en Novembre 2008, Mesh Object Browser est une petite application Winform permettant de visualiser au travers d’une Treeview notre Resourcel Model avec la possibilité de pouvoir éditer nos LiveItem dans une grille de propriétés.

MOB n’est sortie qu’un mois après, en Janvier 2009, sur la plateforme CodePlex en code ouvert à l’adresse : http://mob.codeplex.com/

Pour citer le magazine Programmez! :

Il s’agit pour le développeur de naviguer rapidement et simplement dans les objets Mesh et leur contenu. Il aidera donc grandement le développeur Mesh. L’outil est écrit en C#. Créé à l’origine par Sébastien Warin (qui a victorieusement participé à ImagineCup 2008 France), il est aujourd’hui rendu disponible par l’équipe Wygwam. Il permet outre la navigation de gérer les contenus des objets. Parmi les objets supportés en Live Desktop ou en desktop local : contacts, profils, Mesh Objects, Devices et les News.

Retrouvez Mesh Object Browser :

• Site du projet sur Codeplex : http://mob.codeplex.com/
• News du magazine Programmez! : http://www.programmez.com/actualites.php?titre=Naviguez-dans-Mesh&id_actu=4099
• News sur le blog de Redo : http://blogs.developpeur.org/redo/archive/2009/01/08/mesh-objects-browser-mob-1-0-sur-codeplex.aspx

2ème projet : Live Framework Explorer 1.0

MOB offrait une représentation graphique facile à comprendre avec la possibilité de pouvoir éditer facilement nos LiveItem. Mais certaines informations nécessitent encore le Live Framework Resource Explorer quand la représentation graphique ne suffisait plus.

Du point de vue du développeur, nous nous retrouvons avec trois programmes lancés systématiquement :

• Visual Studio pour notre développement
• Mesh Object Browser pour pouvoir avoir une représentation graphique rapide
• Live Framework Resource Model pour pouvoir fouiller les propriétés cachées dans nos LiveItem

C’est donc suite à ce constat renforcé avec les feedbacks des utilisateurs de MOB que j’ai développé fin Janvier ce qui allait devenir le Live Framework Explorer.

Le Live Framework Explorer (ou LFE) est un addin à Visual Studio qui va permettre accéder à votre Resource Model directement depuis votre environnement de développement. En quelque sorte l’intégration de MOB dans Visual Studio.

L’autre particularité de LFE comparé à MOB est son architecture extensible permettant d’enrichir les fonctionnalités de LFE par le développement de plugin.

L’un des premiers plugins développés est le "View in browser" qui permet, toujours depuis Visual Studio, de pouvoir ouvrir le flux du LiveItem sélectionné avec la possibilité de sélectionner le format de sortie. En clair, l’intégration du Live Framework Resource Browser comme plugin de LFE.

Cela permet donc d’unifier le LFRB et MOB dans un seul outil intégré lui-même à votre environnement de développement Visual Studio.

Depuis la beta 1 fin Janvier, d’autre plugin ont vu le jour comme la possibilité d’uploader/downloader des fichiers directement depuis LFE, d’ajouter, modifier et supprimer des LiveItem, d’inviter des membres sur un MeshObject, etc…

Annonce au MIX09 de Las Vegas

D’abord présenté aux équipes de Microsoft Corp. en la personne de James Senior, LFE a tout de suite suscité un grand intérêt auprès de Microsoft. Si bien que Microsoft m’a gentiment invité à passer 3 jours à Las Vegas à l’occasion du MIX, et a proposé à Gregory Renard (Redo) une session sur le LiveFX afin de lancer officiellement la sortie de LFE !

Ce fut aussi pour moi, l’occasion pour moi de rencontrer quelques personnes culte chez Microsoft comme Scott Guthrie (Corporate Vice President, Microsoft .NET Developer Platform), Nikhil Kothari (software architect in the .NET Developer Platform group), James Senior (Live Services Evangelist), Bill Buxton (Principal Researcher Microsoft Research) et enfin Nigel Ellis (Principal Architect of Microsoft SQL Services)

LFE en Beta 5 et code ouvert sur CodePlex

Depuis notre retour du MIX, LFE a encore évolué et est actuellement disponible en version Beta 5 sur CodePlex à l’adresse http://lfe.codeplex.com/

Téléchargement direct : http://lfe.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=26624

Liste des plugins à ce jour :

• FileDownloadingPlugin : to download a LiveMeshFile
• FileUploadingPlugin : to upload a LiveMeshFile in a LiveMeshFolder
• LiveFxBrowserPlugin : a LiveFxBrowserResource integration to browse in HTTP your Mesh and custom easily the output format (JSON, RSS, ATOM or POX)
• LiveItemEditorPlugin : to edit a resource in a PropertyGrid and update this content on your Mesh
• CreateLiveItemPlugin : to create an LiveItem in a LiveItemCollection (the LiveItem is type of TMeshItem of the collection)
• DeleteLiveItemPlugin : to remove a LiveItem from a LiveItemCollection
• VSSettingsImportExportPlugin : to import/export Visual Studio Settings file in Mesh
• AddInvitationPlugin : to share your MeshObject by sending invitation

Alors n’hésitez plus, au même titre que le Reflector est pour le développement .NET, Live Framework Explorer (LFE) est l’outil indispensable pour vos développements sur LiveFX

A voir aussi :

• Annonce par James Seniors (Microsoft Corp) : http://blogs.technet.com/james/archive/2009/03/19/announcing-the-live-framework-explorer-for-visual-studio.aspx
• Annonce par Gregory Renard (CTO Wygwam) : http://blogs.codes-sources.com/redo/archive/2009/03/19/mix-2009-lancement-du-live-framework-explorer-pour-visual-studio.aspx

http://lfe.codeplex.com/

Après avoir vu le fonctionnement d’un Add-In au sein de Visual Studio (voir part 1) et comment créer ses propres fenêtres « VS like » hébergeant nos UserControls .NET (voir part 2), nous allons voir dans cette 3ème partie quelques interactions possibles avec l’IDE.

C’est depuis notre objet DTE2 (le _applicationObject dans notre classe Connect) que nous avons la possibilité d’accéder à notre IDE depuis le code. Voyons tout cela plus détails avant d’illustrer quelques interactions avec la StatusBar, Propeties Window ou encore les Window Panes.

L’objet DTE

L’objet DTE2 (EnvDTE80.DTE2 ou anciennement EnvDTE.DTE) est l’objet de haut niveau du modèle objet de Visual Studio. C’est lui qui nous permet d’interagir avec l’IDE depuis notre code.

Nous nous en sommes déjà servi dans notre part 1 et 2 afin de créer des fenêtres VS (DTE2.Windows) ou encore de rajouter le bouton de notre Add-In dans le menu Tools (DTE2.Commands).

Je vous laisserai observer l’ensemble des membres de notre objet DTE2 que vous pourrez retrouver dans l’intégralité sur la MDSN à l’adresse : http://msdn.microsoft.com/en-us/library/envdte80.dte2_members(VS.80).aspx

Les membres qui nous intéresserons dans cet article :

• ActiveDocument : permet de récupérer le document actuel.
• StatusBar : représente la StatusBar de Visual Studio.
• ItemOperations : permettant d’effectuer des opérations sur des éléments dans VS (ex: créer/ouvrir des documents)
• Windows : permet d’accéder aux fenêtres de VS.

Informer sur l’état de notre Add-In dans la StatusBar

Sans rentrer dans les détails, nous nous servirons principalement de trois membres :

• Clear : permet de reset la StatusBar
• Progress : permet d’afficher une barre de progression dans la Status Bar
• Text : défini le texte à afficher dans la Status Bar

Prenons pour ‘exemple de rajouter le code ci-dessus après la création de notre fenêtre (cf. Part 2) :

1

_applicationObject.StatusBar.Text = "MonAddinDemo lancé !";

Observez le résultat dans notre VS une fois notre Add-In lancé :

Nous avons aussi la possibilité d’afficher une barre de progression avec la méthode Progress. Exemple :

1

_applicationObject.StatusBar.Progress(true, "Etape 1", 33, 100);

Le 1er argument précise si l’on doit afficher la barre de progression. Le 2eme argument est le texte à afficher dans la StatusBar et les deux derniers arguments définissent l’état d’avancement de notre barre de progression (ici 33 pour 100 !).

Le résultat dans notre Visual Studio :

N’oubliez pas de rappeler la méthode Progress en précisant le 1er argument (InProgress) à false pour masquer la barre de progression une fois la tache terminée !

Ouvrir un site web avec les ItemOperations

Les ItemOperations vont permettre de manipuler l’équivalent des fenêtres des dialogues « Ajouter un élément » ou « Créer/Ouvrir un fichier ».

On retrouvera parmi les méthodes de cet objet :

• AddExistingItem : ajoute un élément existant au projet
• AddNewItem : ajoute un nouvel élément au projet
• IsFileOpen : indique si le fichier est ouvert
• Navigate : permet d’ouvrir un URL dans le web browser de VS
• NewFile : crée un nouveau fichier
• OpenFile : ouvre un fichier

Pour l’exemple nous allons simplement ouvrir un site web dans une nouvelle fenêtre. (Cela ressemblera étrangement à notre UC contenant notre Web Browser !)

1
2

_applicationObject.ItemOperations.Navigate("http://sebastien.warin.fr",
    vsNavigateOptions.vsNavigateOptionsNewWindow);

Écrire dans les Output Window Panes

Nous nous souvenons de l’objet EnvDTE80.Windows pour son CreateToolWindow qui nous avait servi dans notre Part 2 pour la création de fenêtre dans Visual Studio.

Nous avons aussi une méthode forte intéressante nommé Item ! Elle permet de récupérer une fenêtre (objet Window) à partir de son Guid. Pour nous aider, l’énumération EnvDTE.Constants contient tous les GUID des fenêtres principales de VS :

Nous allons dans notre exemple, créer un nouveau « Pane » dans la fenêtre de sortie (Output) de Visual Studio. Ajoutons le code ci-dessous :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

private OutputWindowPane monWindowPane = null;
private void EcrireDansMonWindowPane(string texte)
{
    if (monWindowPane == null)
    {
        // Récupération de la fenetre Output (vsWindowKindOutput)
        var window = _applicationObject.Windows.Item(EnvDTE.Constants.vsWindowKindOutput) as Window2;
        var outputWindow = window.Object as OutputWindow;
        // Pour tous les Window Panes dans mon Output
        foreach (OutputWindowPane pane in outputWindow.OutputWindowPanes)
        {
            // Si il existe deja un pane nommée "Mon Addin Demo"
            if (pane.Name == "Mon Addin Demo")
            {
                // sauvegarde la référence dans monWindowPane
                monWindowPane = pane;
                break;
            }
        }
        // Si pas trouvé, on le crée (OutputWindowPanes.Add)
        if (monWindowPane == null)
            monWindowPane = outputWindow.OutputWindowPanes.Add("Mon Addin Demo");
    }
    // Activation du Pane
    monWindowPane.Activate();
    // Ecriture de l'heure et du texte dasn notre pane "Mon Addin Demo"
    monWindowPane.OutputString(string.Format("{0} : {1}\n", DateTime.Now.ToLongTimeString(), texte));
}

Cette méthode cherchera à récupérer notre « Pane » nommé « Mon Addin Demo » ou le créera si celui ci n’existe pas. Une fois récupéré, elle écrira le texte passé en paramètre ainsi que l’heure.

Ajoutons maintenant, après la création de notre fenêtre dans notre méthode OnConnection, le code ci-dessus pour tester notre méthode :

1
2

EcrireDansMonWindowPane("MonAddinDemo lancé");
EcrireDansMonWindowPane("Ceci est un test !");

Observons le résultat dans notre Visual Studio :

Afficher les propriétés d’un objet dans la Properties Window

La Properties Window, bien connu des développeurs, permet d’afficher les propriétés d’un objet dans une sorte de tableau (en WinForm on utilise le PropertyGrid pour reproduire le même rendu) :

Pour passer un objet à cette fenêtre nous utiliserons la méthode SetSelectionContainer en passant la référence à un tableau d’objet (object[]).

Pour cela nous allons créer un nouveau UserControl dans lequel nous placerons un bouton qui appellera le SetSelectionContainer pour afficher un objet de type Personne que nous créerons également :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public partial class UserControl1 : UserControl
{
    public class Personne
    {
        public string Nom { get; set; }
        public string Prenom { get; set; }
        public int Age { get; set; }
    }
 
    public Window Window { get; set; }
 
    public UserControl1()
    {
        InitializeComponent();
    }
 
    private void button1_Click(object sender, EventArgs e)
    {
        object[] tmpl = new object[] { new Personne() { Age=22, Prenom="Sebastien", Nom = "Warin"} };
        Window.SetSelectionContainer(ref tmpl);
    }
}

Dans notre classe Connect, l’appel à la méthode CreateToolWindow2 diffère un peu ! (N’oubliez pas de passer la référence de la Window créée à votre UC !)

1
2
3
4
5
6
7
8
9
10
11

object monUC = null;
var vsWindows = _applicationObject.Windows as Windows2;
// Creation de la fenetre VS
_maWindow = vsWindows.CreateToolWindow2(_addInInstance, Assembly.GetExecutingAssembly().Location,
    typeof(UserControl1).FullName, "Ma 1er fenetre VS", Guid.NewGuid().ToString("B"), ref monUC);
// On passe la ref de notre Window
(monUC as UserControl1).Window = _maWindow;
// Affichage de la fenetre VS
_maWindow.IsFloating = false;
_maWindow.Linkable = false;
_maWindow.Visible = true;

Le résultat dans Visual Studio :

Attention, la méthode SetSelectionContainer ne peut être appelée que par une fenêtre ayant été créée par un CreateToolWindow. C’est pour cela que nous passons l’objet _maWindow à notre UC et que notre UC se sert de cet objet pour appeler le SetSelectionContainer.

Nous aurions pu penser à récupérer la Properties Window pour appeler le SetSelectionContainer comme ci-dessous :

1
2
3
4

// Récuperation de la fenetre de Propriété
var propWin = DTE.Windows.Item(EnvDTE.Constants.vsWindowKindProperties) as Window2;
// Affichage de l'objet dans la Properties Window
propWin.SetSelectionContainer(ref tmpl);

Mais une exception se lèvera vous indiquant que cela n’est possible que par une fenêtre ayant été créée par CreateToolWindow :

1
2

System.Runtime.InteropServices.COMException was caught
   Message="Only tool windows created by Add-ins (Window.CreateToolWindow) can offer Selection"

Récupérer le document en cours : le ActiveDocument

Le ActiveDocument permet de récupérer le document en cours. Vous pouvez par exemple tester si le type du document en cours est de type « Text ». Si oui vous pourrez, grâce à la méthode Object() le récupérer sous forme un TextDocument. Vous pourrez ensuite interagir avec le contenu du document très facilement.

A ce sujet, en Février 2006 (il y a déjà 3 ans !!), je publiais sur mon blog une macro permettant de générer des propriétés très rapidement (http://sebastien.warin.fr/2006/02/07/7-macrosebgenererproprietes/).  La macro utilisait le DTE.ActiveDocument pour générer le code dans vos fichiers sources.

Pour notre exemple nous allons simplement afficher e texte sélectionné dans une MessageBox. Le code est :

1
2
3
4
5

if (_applicationObject.ActiveDocument.Type == "Text")
{
    var txtDoc = _applicationObject.ActiveDocument.Object("TextDocument") as TextDocument;
    MessageBox.Show(txtDoc.Selection.Text);
}

Exécutons notre projet, et ouvrons un fichier de type « Text » dans VS. Sélectionnons du texte au hasard et activons notre Add-In. Le résultat en image :

Conclusion

S’achève ainsi notre découverte des possibilités d’extension par Add-In de votre Visual Studio. Nous avons vu ici quelques interactions possibles avec celui-ci pour s’intégrer le plus possible dans l’IDE.

Nous verrons par la suite quelques tips (astuces) sur le packaging d’Add-In ou encore la personnalisation de l’icône de votre Add-In dans le menu Tools.