Trucs et astuces pour Visual Studio 2008 / Visual Basic 2008 / Visual C# 2008 : Partie 2

Sommaire de la deuxième partie

	Découplez la puissance de Visual Studio 2008 avec les macros !
	Générez votre code à partir des Macros de Visual Studio 2008
	Etendez la Boîte à Outils de Visual Studio 2008

<< Retour à la première partie

Partie 2 : les Macros et la Boîte à Outils

Découplez la puissance de Visual Studio 2008 avec les macros !

Mais les Codes-Snippets ne sont pas une fin en soi, vous pouvez encore aller plus loin dans la démarche en exploitant une autre fonctionnalité trop méconnue et trop peu utilisée de Visual Studio : les Macros !

Effectivement, bien que je sois un adepte des Codes-Snippets, je dois leur reconnaitre une certaine limite dans leur capacité à accompagner le développeur dans des éléments de génération de code et/ou fonctionnalités particulières comme l’automatisation d’une recherche de syntaxe via Google !

(NDLR : on pourrait faire ça pour Live Search aussi, non ? :-) )

Alors comment atteindre de pareils objectifs en un minimum de temps ?  Les macros sont là pour vous aider. Accéder à celles-ci au travers de l’éditeur de macro installé par défaut dans votre Visual Studio.

Pour cela, rien de plus simple, accédez au menu Outils (Tools) et observez la capture suivante présentant l’interface que vous devriez avoir sous les yeux :

Afin de faire mieux connaissance avec les macros, je ne puis que vous encourager à charger le Macro Explorer (Alt+F8) qui vous ouvrira une boîte à outils contenant l’ensemble des macros disponibles par défaut dans votre environnement de développement.

Les macros sont déjà nombreuses et leur objectif est principalement de vous appuyer dans votre apprentissage. La capture précédente vous montre ainsi que non seulement vous aurez un ensemble de macros à disposition (Samples) mais aussi la possibilité de créer vos propres macros, qui dans le cas de cette capture, sont regroupés au sein de WygMacros. Il vous sera ainsi possible d’échanger vos macros avec vos collègues.

Découvrons ainsi une première macro. Pour cela, exploitez l’éditeur de macros qui n’est ni plus ni moins qu’une version de Visual Studio dédié à ce type d’exercice. Vous y accéderez par l’explorateur de macros : faites un clic droit sur une macro afin de faire apparaître le menu contextuel et en choisissez « Edition » (Edit) ou encore passez par Macros / Macros IDE … (Alt+F11) dans le menu Outils (Tools).

Il ne vous reste ainsi plus qu’à découvrir la syntaxe (VB) de création des macros et ensuite à créer les vôtres.

Observez l’exemple suivant permettant d’augmenter la taille de votre font par simple exécution de cette méthode (macro) :

    ' Increases the font size used within the editor.
    Public Sub IncreaseTextEditorFontSize() ' Useful to bind to a keystroke, like Ctrl+Alt+Shift+DownArrow.
        Dim textEditorFontsAndColors As Properties

        textEditorFontsAndColors = DTE.Properties("FontsAndColors", "TextEditor")
        textEditorFontsAndColors.Item("FontSize").Value += fontSizeIncrement
    End Sub

Vous remarquerez en tête de module l’exploitation d’un NameSpace « EnvDTE » qui n’est ni plus ni moins que celui qui aidera à exploiter votre environnement de développement (que ce soit les fenêtres, actions, paramètres, etc.). Vous pourrez ainsi manipuler l’entièreté de Visual Studio à partir de cet élément.

Retrouvez l’ensemble des membres de NameSpace à partir de l’adresse suivante : http://msdn.microsoft.com/en-us/library/envdte.aspx

Vous pourrez ainsi créer autant de macros que vous le souhaitez ! Par exemple, la suivante permet une recherche de mots-clés (syntaxes de code) directement depuis votre environnement de développement :

    Sub GoogleSearch()
        Dim strUrl AsString
        Dim selection As TextSelection = DTE.ActiveDocument.Selection()
        If selection.Text <> "" Then
            strUrl = "www.google.com/search?q=" + selection.Text
            DTE.ExecuteCommand("View.URL", strUrl)
       Else
            MsgBox("Sélectionnez un élément texte")
        End If
    End Sub

(NDLR : personne pour “http://search.live.com/results.aspx?q=” ?)

Haut de page

Générez votre code à partir des Macros de Visual Studio 2008

Mais les macros pourront également vous servir à créer un premier niveau de génération de code ou tout au moins à effectuer des opérations que vous ne pourriez malheureusement faire grâce aux Codes-Snippets. Prenons un exemple relativement simple de génération des membres d’une classe (propriétés – champs) à partir d’une collection de couples « Nom – Type » où le nom est le nom à affecter au membre et le type, celui qui lui est associé. Cette génération devra également s’exécuter dans le bon contexte du langage exploité par l’utilisateur.

Voyons le résultat fonctionnel avant d’explorer un tant soit peu le code en supposant le code suivant dans notre classe employe :

Public Class Employe

Nom String
Prenom String
Salaire Decimal

End Class

Après l’exécution de notre Macro, nous obtiendrions le code suivant :

Public Class Employe

       Private _Nom AsString
       Private _Prenom As String
       Private _Salaire As Decimal

       Public Property Nom() As String
             Get
                     Nom = _Nom
             End Get
             Set (ByVal value AsString)
                     _Nom = value
             End Set
       End Property

       Public Property Prenom() As String
             Get
                     Prenom = _Prenom
             End Get
             Set (ByVal value AsString)
                     _Prenom = value
             End Set
       End Property

       Public Property Salaire() As Decimal
             Get
                     Salaire = _Salaire
             End Get
             Set (ByVal value AsDecimal)
                     _Salaire = value
             End Set
       End Property

End Class

Ceci s’exécute ainsi en moins d’une seconde, délais que vous ne pourriez malheureusement pas obtenir même avec les Codes-Snippets.

Alors comment fonctionne cette macro ? Rien de plus simple ! L’algorithme associé et le code sont relativement basiques, il vous suffit de développer une méthode qui se charge de parcourir votre sélection (la collection de couples nom-type) et pour chaque itération effectuer une manipulation de brute force (génération de texte) en y ajoutant les éléments manquants.

Voici un extrait du point central de cette macro :

   Public Sub GenererProprietes() ' Methode public de la macro

        ' Recuperation de l'extention du fichier
        Dim file As String = DTE.ActiveDocument.FullName
        Dim fileType AsString = FileIO.FileSystem.GetFileInfo(file).Extension

       ' Recuperation du texte selectionné
        Dim textSelection As TextSelection = DTE.ActiveDocument.Selection()

        ' Recuperation des n° de lignes de debut et fin
        '   du texte selectionné
        Dim start_line, end_line As Integer
        start_line = textSelection.TopPoint.Line
        end_line = textSelection.BottomPoint.Line

       ' Initialisation des tampons a vide
        tampon_proprio = ""
        tampon_var = ""

        ' Test si du texte est selectionné
        If textSelection.Text = ""Then
            MsgBox("Aucun texte selectionné !", MsgBoxStyle.Critical, "Erreur")
        ElseIf fileType <> ".vb" And fileType <> ".cs"Then
           ' Test du langage : VB.net ou C# !
            MsgBox("Cette macro ne peut s'executer que sur des fichiers VB.net (.vb) ou C# (.cs) !", MsgBoxStyle.Exclamation, "Erreur de langage")
        Else
            ' Boucle pour toutes les lignes selectionnés
            For i As Integer = start_line To end_line
               ' Allez puis selectionner la ligne
                textSelection.GotoLine(i)
                textSelection.SelectLine()
               ' Enregistrement dans tab (2 dimension) du nom et du type de la propriete
                Dim tab As String() = FormatTab(textSelection.Text.Split(" "))

               ' Si ce n'est pas vide, on crée la variable et la propriete
                If (tab(0) <> "" Or tab(0) <> Nothing) And (tab(1) <> "" Or tab(1) <> Nothing) Then
                   ' Création de la variable stoké dans tampon_var
                    tampon_var = tampon_var + CreateVariable(tab(0), tab(1), fileType) + vbCrLf
                   ' Création de la propriete
                    CreatePropriete(tab(0), tab(1), fileType)
               End If
           Next

            ' On suprrime le texte original
            For j As Integer = start_line To end_line
                textSelection.GotoLine(start_line)
                textSelection.SelectLine()
               textSelection.Delete()
            Next

            ' Pour finir, on insert les declarations des variables
            textSelection.Insert(tampon_var)
            textSelection.NewLine()
            ' .... et les proprietes
            textSelection.Insert(tampon_proprio)
        End If

       'Fin :-)
   End Sub

Retrouvez l’entièreté du code depuis le blog de mon assistant Sébastien Warin à l’adresse suivante : http://sebastien.warin.fr/2006/02/07/7-macrosebgenererproprietes/

Retrouvez d’autres exemples de macros et liens à l’adresse suivante : http://blogs.developpeur.org/redo/search.aspx?q=macros&p=1

Mais revenons maintenant à notre solution, et plus précisément à la classe Employe que nous étions occupés à construire. Celle-ci venant d’être développée en moins de temps qu’il n’a fallu pour le dire, nous pouvons poursuivre notre exemple en ajoutant une nouvelle classe « EmployeMgr » qui aura pour tâche de définir un Generics pour notre classe Employe.

Public Class EmployeMgr

    Public SharedFunction EmployeList() As List(Of Employe)

        Dim empList AsNew List(Of Employe)

        empList.Add(New Employe With {.Nom = "Gregory", _
                                        .Prenom = "Renard", _
                                        .Salaire = 30})

        empList.Add(New Employe With {.Nom = "Aurelien", _
                                .Prenom = "Verla", _
                                .Salaire = 40})

        empList.Add(New Employe With {.Nom = "Renaud", _
                                .Prenom = "Comte", _
                                .Salaire = 50})

        Return empList

    End Function

End Class

Haut de page

Etendez la Boîte à Outils de Visual Studio 2008

Vous avez la possibilité d’ajouter aisément de nouveaux contrôles en plus des contrôles traditionnels en insérant un nouveau Tab (Groupe de contrôles) et en faisant un clic droit sur celui-ci afin d’y ajouter de nouveau Items (contrôles) comme suit :

Vous avez aussi la possibilité d’ajouter des briques de codes sous forme de raccourcis (copier/coller). Comment réaliser ceci ? Rien de plus simple, il vous suffit de copier la parcelle de code cible et de la coller directement dans la boite à outils qui dans le cas d’un fichier de code ouvert est initialement vide. Cette fonctionnalité, très utile dans le cadre de démonstrations et de formations vous immunisera à l’effet démo.

Soyez cependant vigilant lors de la création de vos Items car ceux-ci ne sont enregistrés qu’à la fermeture de Visual Studio.  L’enregistrement s’effectue dan le fichier « CurrentSettings.vssettings » se trouvant dans le répertoire : C:\Users\<VotreNom>\Documents\Visual Studio 2008\Settings

La couche métier de la solution étant maintenant terminée, attaquons-nous à la partie interface utilisateur. Pour cela, créez un nouveau projet de type Winform au sein de votre solution et adaptez le Form1 comme suit :

Il ne nous reste plus qu’à travailler la partie code de ce formulaire afin de charger les données depuis la collection d’employés de la classe EmployeMgr.

Haut de page