Hinzufügen eines Untermenüs zu einem Menü

Artikel
01/12/2024

Diese exemplarische Vorgehensweise baut auf der Demonstration im Hinzufügen eines Menüs zur Visual Studio-Menüleiste auf, indem gezeigt wird, wie Sie dem Menü "TestMenü " ein Untermenü hinzufügen.

Ein Untermenü ist ein sekundäres Menü, das in einem anderen Menü angezeigt wird. Ein Untermenü kann durch den Pfeil identifiziert werden, der seinem Namen folgt. Wenn Sie auf den Namen klicken, wird das Untermenü und die zugehörigen Befehle angezeigt.

Diese exemplarische Vorgehensweise erstellt ein Untermenü in einem Menü in der Visual Studio-Menüleiste und fügt einen neuen Befehl in das Untermenü ein. Die exemplarische Vorgehensweise implementiert auch den neuen Befehl.

Führen Sie die Schritte unter Hinzufügen eines Menüs zur Visual Studio-Menüleiste aus, um das Projekt und das Menüelement zu erstellen. Bei den Schritten in dieser exemplarischen Vorgehensweise wird davon ausgegangen, dass der Name des VSIX-Projekts lautet TopLevelMenu.
Öffnen Sie TestCommandPackage.vsct. Fügen Sie im <Symbols> Abschnitt ein <IDSymbol> Element für das Untermenü, eine für die Untermenügruppe und eine für den Befehl, alle im <GuidSymbol> Knoten "guidTopLevelMenuCmdSet" hinzu. Dies ist derselbe Knoten, der das <IDSymbol> Element für das Menü der obersten Ebene enthält.
```
<IDSymbol name="SubMenu" value="0x1100"/>
<IDSymbol name="SubMenuGroup" value="0x1150"/>
<IDSymbol name="cmdidTestSubCommand" value="0x0105"/>
```

Fügen Sie dem <Menus> Abschnitt das neu erstellte Untermenü hinzu.

<Menu guid="guidTestCommandPackageCmdSet" id="SubMenu" priority="0x0100" type="Menu">
    <Parent guid="guidTestCommandPackageCmdSet" id="MyMenuGroup"/>
    <Strings>
        <ButtonText>Sub Menu</ButtonText>
        <CommandName>Sub Menu</CommandName>
    </Strings>
</Menu>

Das GUID/ID-Paar des übergeordneten Elements gibt die Menügruppe an, die in der Menüleiste von Visual Studio generiert wurde, und ist ein untergeordnetes Element des Menüs der obersten Ebene.

Fügen Sie die in Schritt 2 definierte Menügruppe zum <Groups> Abschnitt hinzu, und machen Sie sie zu einem untergeordneten Element des Untermenüs.

<Group guid="guidTestCommandPackageCmdSet" id="SubMenuGroup" priority="0x0000">
    <Parent guid="guidTestCommandPackageCmdSet" id="SubMenu"/>
</Group>

Fügen Sie dem <Buttons> Abschnitt ein neues <Button> Element hinzu, um den befehl zu definieren, der in Schritt 2 als Element im Untermenü erstellt wurde.

<Button guid="guidTestCommandPackageCmdSet" id="cmdidTestSubCommand" priority="0x0000" type="Button">
    <Parent guid="guidTestCommandPackageCmdSet" id="SubMenuGroup" />
    <Icon guid="guidImages" id="bmpPic2" />
    <Strings>
       <CommandName>cmdidTestSubCommand</CommandName>
       <ButtonText>Test Sub Command</ButtonText>
    </Strings>
</Button>

Erstellen Sie die Projektmappe, und beginnen Sie mit dem Debuggen. Die experimentelle Instanz sollte angezeigt werden.
Klicken Sie auf " TestMenü" , um ein neues Untermenü mit dem Namen "Untermenü" anzuzeigen. Klicken Sie auf "Untermenü", um das Untermenü zu öffnen und einen neuen Befehl zu sehen: Befehl "Unter testen". Beachten Sie, dass durch Klicken auf den Befehl "Unter testen" nichts ausgeführt wird.

Befehl hinzufügen

Öffnen Sie TestCommand.cs , und fügen Sie die folgende Befehls-ID nach der vorhandenen Befehls-ID hinzu.
```
public const int cmdidTestSubCmd = 0x0105;
```

Fügen Sie den Unterbefehl hinzu. Suchen Sie den Befehlskonstruktor. Fügen Sie die folgenden Zeilen direkt nach dem Aufruf der AddCommand Methode hinzu.

CommandID subCommandID = new CommandID(CommandSet, cmdidTestSubCmd);
MenuCommand subItem = new MenuCommand(new EventHandler(SubItemCallback), subCommandID);
commandService.AddCommand(subItem);

Der SubItemCallback Befehlshandler wird später definiert. Der Konstruktor sollte nun wie folgt aussehen:

private TestCommand(Package package)
{
    if (package == null)
    {
        throw new ArgumentNullException("package");
    }

    this.package = package;

    OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
    if (commandService != null)
    {
        var menuCommandID = new CommandID(CommandSet, CommandId);
        var menuItem = new MenuCommand(this.MenuItemCallback, menuCommandID);
        commandService.AddCommand(menuItem);

        CommandID subCommandID = new CommandID(CommandSet, cmdidTestSubCmd);
        MenuCommand subItem = new MenuCommand(new EventHandler(SubItemCallback), subCommandID);
        commandService.AddCommand(subItem);
    }
}

Fügen Sie SubItemCallback()hinzu. Dies ist die Methode, die aufgerufen wird, wenn auf den neuen Befehl im Untermenü geklickt wird.

private void SubItemCallback(object sender, EventArgs e)
{
    ThreadHelper.ThrowIfNotOnUIThread();
    IVsUIShell uiShell = this.package.GetService<SVsUIShell, IVsUIShell>();
    Guid clsid = Guid.Empty;
    int result;
    uiShell.ShowMessageBox(
        0,
        ref clsid,
        "TestCommand",
        string.Format(CultureInfo.CurrentCulture,
        "Inside TestCommand.SubItemCallback()",
        this.ToString()),
        string.Empty,
        0,
        OLEMSGBUTTON.OLEMSGBUTTON_OK,
        OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST,
        OLEMSGICON.OLEMSGICON_INFO,
        0,
        out result);
}

Erstellen Sie das Projekt, und starten Sie das Debugging. Die experimentelle Instanz sollte angezeigt werden.
Klicken Sie im Menü "TestMenü" auf "Unter" , und klicken Sie dann auf "Unterbefehl testen". Ein Meldungsfeld sollte angezeigt und der Text "Test Command Inside TestCommand.SubItemCallback()" angezeigt werden.

Freigeben über