Comment : ajouter une commande au menu contextuelHow to: Add a Command to the Shortcut Menu

Vous pouvez ajouter des commandes de menu à votre langage spécifique à un domaine (DSL, Domain-Specific Language) pour que vos utilisateurs puissent effectuer des tâches spécifiques à votre solution DSL.You can add menu commands to your domain-specific language (DSL) so that your users can perform tasks that are specific to your DSL. Les commandes apparaissent dans le menu contextuel quand les utilisateurs cliquent avec le bouton droit sur le diagramme.The commands appear on the context (shortcut) menu when users right-click on the diagram. Vous pouvez définir une commande pour qu'elle apparaisse dans le menu uniquement dans des circonstances spécifiques.You can define a command so that it only appears in the menu in specific circumstances. Par exemple, vous pouvez rendre la commande visible uniquement quand l'utilisateur clique sur des types d'éléments spécifiques ou sur des éléments qui sont dans des états spécifiques.For example, you can make the command visible only when the user clicks specific types of element, or elements in specific states.

En résumé, les étapes sont effectuées dans le projet DslPackage comme suit :In summary, the steps are performed in the DslPackage project, as follows:

  1. Déclarez la commande dans Commands.vsctDeclare the command in Commands.vsct

  2. Mettre à jour le numéro de version de package dans Package.tt.Update the package version number in Package.tt. Vous devez effectuer cette opération chaque fois que vous modifiez Commands.vsct.You have to do this whenever you change Commands.vsct

  3. Écrire des méthodes dans la classe CommandSet pour afficher la commande et pour définir ce que vous souhaitez la commande.Write methods in the CommandSet class to make the command visible and to define what you want the command to do.

    Pour obtenir des exemples, consultez la site Web Visualization and Modeling SDK.For samples, see the Visualization and Modeling SDK website.

Note

Vous pouvez aussi modifier le comportement de certaines commandes existantes telles que Couper, Coller, Sélectionner tout et Imprimer en substituant des méthodes dans CommandSet.cs.You can also modify the behavior of some existing commands such as Cut, Paste, Select All, and Print by overriding methods in CommandSet.cs. Pour plus d’informations, consultez Comment : modifier une commande de Menu Standard.For more information, see How to: Modify a Standard Menu Command.

Définition d'une commande à l'aide de l'infrastructure MEFDefining a Command using MEF

L'infrastructure MEF (Managed Extension Framework) fournit une alternative pour la définition de commandes de menu dans le menu de diagramme.Managed Extension Framework (MEF) provides an alternative method of defining menu commands on the diagram menu. Son objectif principal est de faire en sorte qu'une solution DSL puisse être étendue par vous-même ou par d'autres parties.Its primary purpose is to enable a DSL to be extended by you or by other parties. Les utilisateurs peuvent choisir d'installer uniquement la solution DSL ou d'installer à la fois la solution DSL et les extensions.Users can choose to install just the DSL, or can install both the DSL and extensions. Cependant, l'infrastructure MEF réduit également la charge de travail liée à la définition des commandes de menu contextuel, après le travail initial d'activation de l'infrastructure MEF sur la solution DSL.However, MEF also reduces the work of defining shortcut menu commands, after the initial work to enable MEF on the DSL.

Appliquez la méthode décrite dans cette rubrique dans les cas suivants :Use the method in this topic if:

  1. Vous souhaitez définir des commandes de menu dans des menus autres que le menu contextuel accessible par un clic droit.You want to define menu commands on menus other than the right-click shortcut menu.

  2. Vous souhaitez définir des regroupements spécifiques de commandes dans le menu.You want to define specific groupings of commands in the menu.

  3. Vous ne souhaitez pas que d'autres personnes puissent étendre la solution DSL avec leurs propres commandes.You do not want to enable others to extend the DSL with their own commands.

  4. Vous ne souhaitez définir qu'une seule commande.You only want to define one command.

    Autrement, vous pouvez utiliser la méthode MEF pour définir des commandes.Otherwise, consider using the MEF method to define commands. Pour plus d’informations, consultez étendre votre DSL à l’aide de MEF.For more information, see Extend your DSL by using MEF.

Déclarez la commande dans Commands.VsctDeclare the Command in Commands.Vsct

La déclaration des commandes de menu s'effectue dans DslPackage\Commands.vsct.Menu commands are declared in DslPackage\Commands.vsct. Ces définitions spécifient les étiquettes des éléments de menu et l'emplacement où est elles apparaissent dans les menus.These definitions specify the labels of the menu items and where they appear on the menus.

Le fichier que vous modifiez, Commands.vsct, importe les définitions à partir de plusieurs fichiers .h, qui sont trouvent dans le répertoire chemin d’installation du Kit de développement logiciel Visual Studio\VisualStudioIntegration\Common\Inc. Il comprend également GeneratedVsct.vsct, qui est généré à partir de votre définition DSL.The file that you edit, Commands.vsct, imports definitions from several .h files, which are located in the directory Visual Studio SDK install path\VisualStudioIntegration\Common\Inc. It also includes GeneratedVsct.vsct, which is generated from your DSL definition.

Pour plus d’informations sur les fichiers .vsct, consultez Visual Studio Command Table (. Fichiers VSCT).For more information about .vsct files, see Visual Studio Command Table (.Vsct) Files.

Pour ajouter la commandeTo add the command

  1. Dans l’Explorateur de solutions, sous le DslPackage de projet, ouvrez Commands.vsct.In Solution Explorer, under the DslPackage project, open Commands.vsct.

  2. Dans l'élément Commands, définissez un ou plusieurs boutons et un groupe.In the Commands element, define one or more buttons and a group. A bouton est un élément dans le menu.A button is an item on the menu. A groupe est une section dans le menu.A group is a section in the menu. Pour définir ces éléments, ajoutez les éléments suivants :To define these items, add the following elements:

    <!-- Define a group - a section in the menu -->
    <Groups>
      <Group guid="guidCustomMenuCmdSet" id="grpidMyMenuGroup" priority="0x0100">
        <!-- These symbols are defined in GeneratedVSCT.vsct -->
        <Parent guid="guidCmdSet" id="menuidContext" />
      </Group>
    </Groups>
    <!-- Define a button - a menu item - inside the Group -->
    <Buttons>
      <Button guid="guidCustomMenuCmdSet" id="cmdidMyContextMenuCommand"
        priority="0x0100" type="Button">
        <Parent guid="guidCustomMenuCmdSet" id="grpidMyMenuGroup"/>
        <!-- If you do not want to place the command in your own Group,
             use Parent guid="guidCmdSet" id="grpidContextMain".
             These symbols are defined in GeneratedVSCT.vsct -->
        <CommandFlag>DynamicVisibility</CommandFlag>
        <Strings>
          <ButtonText>My Context Menu Command</ButtonText>
        </Strings>
      </Button>
    </Buttons>
    

    Note

    Chaque bouton ou groupe est identifié par un GUID et un ID entier.Each button or group is identified by a GUID and an integer ID. Vous pouvez créer plusieurs groupes et boutons avec le même GUID.You can create several groups and buttons with the same GUID. Cependant, ils doivent avoir des ID différents.However, they must have different IDs. Les noms des GUID et ID sont traduites en réel GUID et ID numériques dans le <Symbols> nœud.The GUID names and ID names are translated to actual GUIDs and numeric IDs in the <Symbols> node.

  3. Ajoutez une contrainte de visibilité pour la commande pour qu'elle soit chargée uniquement dans le contexte de votre langage spécifique à un domaine.Add a visibility constraint for the command so that it is loaded only in the context of your domain-specific language. Pour plus d’informations, consultez VisibilityConstraints élément.For more information, see VisibilityConstraints Element.

    Pour cela, ajoutez les éléments suivants à l'élément CommandTable après l'élément Commands.To do this, add the following elements in the CommandTable element after the Commands element.

    <VisibilityConstraints>
      <!-- Ensures the command is only loaded for this DSL -->
      <VisibilityItem guid="guidCustomMenuCmdSet" id="cmdidMyContextMenuCommand"
        context="guidEditor"/>
    </VisibilityConstraints>
    
  4. Définissez les noms que vous avez utilisés pour les GUID et les ID.Define the names that you used for the guids and ids. Pour cela, ajoutez un élément Symbols dans l'élément CommandTable après l'élément Commands.To do this, add a Symbols element in the CommandTable element after the Commands element.

    <Symbols>
      <!-- Substitute a unique GUID for the placeholder: -->
      <GuidSymbol name="guidCustomMenuCmdSet"
        value="{00000000-0000-0000-0000-000000000000}" >
        <IDSymbol name="grpidMyMenuGroup" value="0x01001"/>
        <IDSymbol name="cmdidMyContextMenuCommand" value="0x00001"/>
      </GuidSymbol>
    </Symbols>
    
  5. Remplacez {000...000} par un GUID qui identifie vos groupes et éléments de menu.Replace {000...000} with a GUID that identifies your groups and menu items. Pour obtenir un nouveau GUID, utilisez la Create GUID outil sur le outils menu.To obtain a new GUID, use the Create GUID tool on the Tools menu.

    Note

    Si vous ajoutez d'autres groupes ou éléments de menu, vous pouvez utiliser le même GUID.If you add more groups or menu items, you can use the same GUID. Cependant, vous devez utiliser de nouvelles valeurs pour IDSymbols.However, you must use new values for the IDSymbols.

  6. Dans le code que vous avez copié à partir de cette procédure, remplacez chaque occurrence des chaînes suivantes par vos propres chaînes :In the code you have copied from this procedure, replace each occurrence of the following strings with your own strings:

    • grpidMyMenuGroup

    • cmdidMyContextMenuCommand

    • guidCustomMenuCmdSet

    • My Context Menu Command

Mettre à jour la Version du Package dans Package.ttUpdate the Package Version in Package.tt

Chaque fois que vous ajoutez ou modifiez une commande, mettez à jour le paramètre version de l'objet ProvideMenuResourceAttribute qui est appliqué à la classe de package avant de publier la nouvelle version de votre langage spécifique à un domaine.Whenever you add or change a command, update the version parameter of the ProvideMenuResourceAttribute that is applied to the package class before you release the new version of your domain-specific language.

La classe de package étant définie dans un fichier généré, vous devez mettre à jour l'attribut dans le fichier de modèle de texte qui génère le fichier Package.cs.Because the package class is defined in a generated file, update the attribute in the text template file that generates the Package.cs file.

Pour mettre à jour le fichier Package.ttTo update the Package.tt file

  1. Dans l’Explorateur de solutions, dans le DslPackage de projet, dans le GeneratedCode dossier, ouvrez le fichier Package.tt.In Solution Explorer, in the DslPackage project, in the GeneratedCode folder, open the Package.tt file.

  2. Recherchez l'attribut ProvideMenuResource.Locate the ProvideMenuResource attribute.

  3. Incrémentez le paramètre version de l'attribut, qui est le second paramètre.Increment the version parameter of the attribute, which is the second parameter. Si vous le souhaitez, vous pouvez écrire le nom du paramètre de manière explicite, pour vous rappeler sa fonctionIf you want, you can write the parameter name explicitly to remind you of its purpose. Par exemple :For example:

    [VSShell::ProvideMenuResource("1000.ctmenu", version: 2 )]

Définir le comportement de la commandeDefine the Behavior of the Command

Votre solution DSL possède déjà certaines commandes qui sont implémentées dans une classe partielle déclarée dans DslPackage\GeneratedCode\CommandSet.cs.Your DSL already has some commands that are implemented in a partial class that is declared in DslPackage\GeneratedCode\CommandSet.cs. Pour ajouter de nouvelles commandes, vous devez étendre cette classe en créant un fichier qui contient une déclaration partielle de la même classe.To add new commands, you must extend this class by creating a new file that contains a partial declaration of the same class. Le nom de la classe est généralement <YourDslName >CommandSet.The name of the class is usually <YourDslName>CommandSet. Il est utile de commencer par vérifier le nom de la classe et inspecter son contenu.It is useful to begin by verifying the name of the class and inspecting its contents.

La classe de jeu de commandes est dérivée de CommandSet.The command set class is derived from CommandSet.

Pour étendre la classe CommandSetTo extend the CommandSet class

  1. Dans l'Explorateur de solutions, dans le projet DslPackage, ouvrez le dossier GeneratedCode, puis regardez sous CommandSet.tt et ouvrez son fichier généré CommandSet.cs.In Solution Explorer, in the DslPackage project, open the GeneratedCode folder and then look under CommandSet.tt and open its generated file CommandSet.cs. Notez l'espace de noms et le nom de la première classe qui y est définie.Note the namespace and the name of the first class that is defined there. Par exemple, vous pouvez voir :For example, you might see:

    namespace Company.Language1

    { ... internal partial class Language1CommandSet : ...

  2. Dans DslPackage, créez un dossier nommé Code personnalisé.In DslPackage, create a folder that is named Custom Code. Dans ce dossier, créez un nouveau fichier de classe nommé CommandSet.cs.In this folder, create a new class file that is named CommandSet.cs.

  3. Dans le nouveau fichier, écrivez une déclaration partielle dont l'espace de noms et le nom sont les mêmes que ceux de la classe partielle générée.In the new file, write a partial declaration that has the same namespace and name as the generated partial class. Par exemple :For example:

    namespace Company.Language1 /* Make sure this is correct */

    { internal partial class Language1CommandSet { ...

    Remarque si vous avez utilisé le modèle de classe pour créer le fichier, vous devez corriger l’espace de noms et le nom de classe.Note If you used the class template to create the new file, you must correct both the namespace and the class name.

Étendre la classe de jeu de commandesExtend the Command Set class

Votre code de jeu de commandes devra généralement importer les espaces de noms suivants :Your command set code will typically need to import the following namespaces:

using System;
using System.Collections.Generic;
using System.ComponentModel.Design;
using System.Linq;
using Microsoft.VisualStudio.Modeling;
using Microsoft.VisualStudio.Modeling.Diagrams;
using Microsoft.VisualStudio.Modeling.Shell;

Ajustez l'espace de noms et le nom de la classe pour qu'ils correspondent à ceux mentionnés dans le fichier CommandSet.cs généré :Adjust the namespace and the class name to match those in the generated CommandSet.cs:

namespace Company.Language1 /* Make sure this is correct */
{
  // Same class as the generated class.
  internal partial class Language1CommandSet
  {

Vous devez définir deux méthodes, une pour déterminer quand la commande sera visible dans le menu contextuel et l'autre pour exécuter la commande.You have to define two methods, one to determine when the command will be visible on the context menu, and the other to perform the command. Ces méthodes ne sont pas des substitutions ; au lieu de cela, vous les inscrivez dans une liste de commandes.These methods are not overrides; instead, you register them in a list of commands.

Définir quand la commande sera visibleDefine when the command will be visible

Pour chaque commande, définissez une méthode OnStatus... qui détermine si la commande apparaîtra dans le menu et si elle sera activée ou grisée. Définissez les propriétés Visible et Enabled de MenuCommand, comme illustré dans l'exemple suivant.For each command, define an OnStatus... method that determines whether the command will appear on the menu, and whether it will be enabled or greyed out. Set the Visible and Enabled properties of the MenuCommand, as shown in the following example. Cette méthode est appelée pour construire le menu contextuel chaque fois que l'utilisateur clique avec le bouton droit sur le diagramme. Elle doit donc fonctionner rapidement.This method is called in order to construct the shortcut menu every time that the user right-clicks the diagram, so it must work quickly.

Dans cet exemple, la commande est visible uniquement quand l'utilisateur a sélectionné un type de forme spécifique et elle est activée uniquement quand au moins l'un des éléments sélectionnés est dans un état particulier.In this example, the command is visible only when the user has selected a particular type of shape, and is enabled only when at least one of the selected elements is in a particular state. L'exemple est basé sur le modèle DSL de diagramme de classe et ClassShape et ModelClass sont des types qui sont définis dans la solution DSL :The example is based on the Class Diagram DSL template, and ClassShape and ModelClass are types that are defined in the DSL:

private void OnStatusMyContextMenuCommand(object sender, EventArgs e)
{
  MenuCommand command = sender as MenuCommand;
  command.Visible = command.Enabled = false;
  foreach (object selectedObject in this.CurrentSelection)
  {
    ClassShape shape = selectedObject as ClassShape;
    if (shape != null)
    {
      // Visibility depends on what is selected.
      command.Visible = true;
      ModelClass element = shape.ModelElement as ModelClass;
      // Enabled depends on state of selection.
      if (element != null && element.Comments.Count == 0)
      {
        command.Enabled = true;
        return; // seen enough
} } } }

Les fragments suivants sont souvent utiles dans les méthodes OnStatus :The following fragments are frequently useful in OnStatus methods:

  • this.CurrentSelection.this.CurrentSelection. La forme sur laquelle l'utilisateur a cliqué avec le bouton droit est toujours incluse dans cette liste.The shape that the user right-clicked is always included in this list. Si l'utilisateur clique sur une partie vierge du diagramme, ce dernier est le seul membre de la liste.If the user clicks on a blank part of the diagram, the Diagram is the only member of the list.

  • this.IsDiagramSelected() - true Si l’utilisateur a cliqué sur une partie vide du diagramme.this.IsDiagramSelected() - true if the user clicked a blank part of the diagram.

  • this.IsCurrentDiagramEmpty()

  • this.IsSingleSelection() - l'utilisateur n'a pas sélectionné plusieurs objets.this.IsSingleSelection() - the user did not select multiple objects

  • this.SingleSelection - forme ou diagramme sur lequel l'utilisateur a cliqué avec le bouton droit.this.SingleSelection - the shape or diagram that the user right-clicked

  • shape.ModelElement as MyLanguageElement - élément de modèle représenté par une forme.shape.ModelElement as MyLanguageElement - the model element represented by a shape.

    En règle générale, vous devez faire en sorte que la propriété Visible dépende de ce qui est sélectionné et que la propriété Enabled dépende de l'état des éléments sélectionnés.As a general guideline, make the Visible property depend on what is selected, and make the Enabled property depend on the state of the selected elements.

    Une méthode OnStatus ne doit pas modifier l'état du magasin.An OnStatus method should not change the state of the Store.

Définir ce que fait la commandeDefine what the command does

Pour chaque commande, définissez une méthode OnMenu... qui exécute l'action requise quand l'utilisateur clique sur la commande de menu.For each command, define an OnMenu... method that performs the required action when the user clicks the menu command.

Si vous modifiez des éléments de modèle, vous devez le faire dans une transaction.If you make changes to model elements, you must do so inside a transaction. Pour plus d’informations, consultez Comment : modifier une commande de Menu Standard.For more information, see How to: Modify a Standard Menu Command.

Dans cet exemple, ClassShape, ModelClass et Comment sont des types définis dans la solution DSL, qui est dérivée du modèle DSL de diagramme de classe.In this example, ClassShape, ModelClass, and Comment are types that are defined in the DSL, which is derived from the Class Diagram DSL template.

private void OnMenuMyContextMenuCommand(object sender, EventArgs e)
{
  MenuCommand command = sender as MenuCommand;
  Store store = this.CurrentDocData.Store;
  // Changes to elements and shapes must be performed in a Transaction.
  using (Transaction transaction =
       store.TransactionManager.BeginTransaction("My command"))
  {
    foreach (object selectedObject in this.CurrentSelection)
    {
      // ClassShape is defined in my DSL.
      ClassShape shape = selectedObject as ClassShape;
      if (shape != null)
      {
        // ModelClass is defined in my DSL.
        ModelClass element = shape.ModelElement as ModelClass;
        if (element != null)
        {
          // Do required action here - for example:

          // Create a new element. Comment is defined in my DSL.
          Comment newComment = new Comment(element.Partition);
          // Every element must be the target of an embedding link.
          element.ModelRoot.Comments.Add(newComment);
          // Set properties of new element.
          newComment.Text = "This is a comment";
          // Create a reference link to existing object.
          element.Comments.Add(newComment);
        }
      }
    }
    transaction.Commit(); // Don't forget this!
  }
}

Pour plus d’informations sur la navigation d’un objet à l’objet dans le modèle, ainsi que sur la création d’objets et des liens, consultez Comment : modifier une commande de Menu Standard.For more information about how to navigate from object to object in the model, and about how to create objects and links, see How to: Modify a Standard Menu Command.

Inscrire la commandeRegister the command

Répétez en C# les déclarations des valeurs de GUID et d'ID que vous avez effectuées dans la section Symbols de CommandSet.vsct :Repeat in C# the declarations of the GUID and ID values that you made in the Symbols section of CommandSet.vsct:

private Guid guidCustomMenuCmdSet =
    new Guid("00000000-0000-0000-0000-000000000000");
private const int grpidMyMenuGroup = 0x01001;
private const int cmdidMyContextMenuCommand = 1;

Utilisez la même valeur GUID que vous avez inséré dans Commands.vsct.Use the same GUID value as you inserted in Commands.vsct.

Note

Si vous modifiez la section Symbols du fichier VSCT, vous devez aussi modifier ces déclarations pour qu'elles correspondent.If you change the Symbols section of the VSCT file, you must also change these declarations to match. Vous devez également incrémenter le numéro de version dans Package.tt.You should also increment the version number in Package.tt

Inscrivez vos commandes de menu dans le cadre de ce jeu de commandes.Register your menu commands as part of this command set. GetMenuCommands() est appelée une fois le diagramme initialisé :GetMenuCommands() is called once when the diagram is initialized:

protected override IList<MenuCommand> GetMenuCommands()
{
  // Get the list of generated commands.
  IList<MenuCommand> commands = base.GetMenuCommands();
  // Add a custom command:
  DynamicStatusMenuCommand myContextMenuCommand =
    new DynamicStatusMenuCommand(
      new EventHandler(OnStatusMyContextMenuCommand),
      new EventHandler(OnMenuMyContextMenuCommand),
      new CommandID(guidCustomMenuCmdSet, cmdidMyContextMenuCommand));
  commands.Add(myContextMenuCommand);
  // Add more commands here.
  return commands;
}

Tester la commandeTest the Command

Générez et exécutez la solution DSL dans une instance expérimentale de Visual Studio.Build and run the DSL in an experimental instance of Visual Studio. La commande doit apparaître dans le menu contextuel dans les situations que vous avez spécifiées.The command should appear in the shortcut menu in the situations you have specified.

Pour exercer la commandeTo exercise the command

  1. Sur le l’Explorateur de solutions barre d’outils, cliquez sur transformer tous les modèles.On the Solution Explorer toolbar, click Transform All Templates.

  2. Appuyez sur F5 pour régénérer la solution et démarrer le débogage du langage spécifique à un domaine dans la build expérimentale.Press F5 to rebuild the solution, and start debugging the domain-specific language in the experimental build.

  3. Dans la build expérimentale, ouvrez un exemple de diagramme.In the experimental build, open a sample diagram.

  4. Cliquez avec le bouton droit sur différents éléments du diagramme pour vérifier que la commande est activée ou désactivée correctement et affichée ou masquée de manière appropriée, en fonction de l'élément sélectionné.Right-click various items in the diagram to verify that the command is correctly enabled or disabled, and appropriately shown or hidden, depending on the selected item.

Résolution des problèmesTroubleshooting

Commande n’apparaît pas dans le menu :Command does not appear in menu:

  • La commande apparaît uniquement dans les instances de débogage de Visual Studio jusqu'à ce que vous installiez le package DSL.The command will appear only in debugging instances of Visual Studio, until you install the DSL package. Pour plus d’informations, consultez déploiement de Solutions de langage spécifique à un domaine.For more information, see Deploying Domain-Specific Language Solutions.

  • Assurez-vous que votre exemple expérimental a l'extension de nom de fichier correcte pour cette solution DSL.Make sure that your experimental sample has the correct file name extension for this DSL. Pour vérifier l'extension de nom de fichier, ouvrez DslDefinition.dsl dans l'instance principale de Visual Studio.To check the file name extension, open DslDefinition.dsl in the main instance of Visual Studio. Ensuite, dans l'Explorateur DSL, cliquez avec le bouton droit sur le nœud Éditeur, puis cliquez sur Propriétés.Then in DSL Explorer, right-click the Editor node, and then click Properties. Dans la fenêtre Propriétés, examinez la propriété FileExtension.In the Properties window, examine the FileExtension property.

  • Vous avez incrémenter le numéro de version de package?Did you increment the package version number?

  • Définissez un point d'arrêt au début de votre méthode OnStatus.Set a breakpoint at the beginning of your OnStatus method. Elle doit s'arrêter quand vous cliquez avec le bouton droit sur une partie quelconque du diagramme.It should break when you right-click over any part of the diagram.

    Méthode de OnStatus n’est pas appelée:OnStatus method is not called:

    • Assurez-vous que les GUID et les ID dans votre code CommandSet correspondent à ceux de la section Symbols de Commands.vsct.Make sure that the GUIDs and IDs in your CommandSet code match those in the Symbols section of Commands.vsct.

    • Dans Commands.vsct, assurez-vous que le GUID et l'ID dans chaque nœud Parent identifient le groupe parent correct.In Commands.vsct, make sure that the GUID and ID in every Parent node identify the correct parent Group.

    • Dans une invite de commandes Visual Studio, tapez devenv /rootsuffix exp /setup.In a Visual Studio command prompt, type devenv /rootsuffix exp /setup. Ensuite, redémarrez l'instance de débogage de Visual Studio.Then restart the debugging instance of Visual Studio.

  • Parcourez la méthode OnStatus pour vérifier que command.Visible et command.Enabled ont la valeur True.Step through the OnStatus method to verify that command.Visible and command.Enabled are set to true.

    Texte du menu incorrect s’affiche, ou commande s’affiche au mauvais endroit:Wrong menu text appears, or command appears in the wrong place:

  • Assurez-vous que la combinaison de GUID et ID est unique à cette commande.Make sure that the combination of GUID and ID is unique to this command.

  • Assurez-vous d'avoir désinstallé les versions antérieures du package.Make sure that you have uninstalled earlier versions of the package.

Voir aussiSee Also

Note

Dans Visual Studio 2017, le SDK de Transformation de modèle de texte et le SDK de modélisation de Visual Studio sont installés automatiquement lorsque vous installez des fonctionnalités spécifiques de Visual Studio.In Visual Studio 2017, the Text Template Transformation SDK and the Visual Studio Modeling SDK are installed automatically when you install specific features of Visual Studio. Pour plus d’informations, consultez ce billet de blog.For more details, see this blog post.