Exemplarische Vorgehensweise: Eine Optionsseite erstellen

Artikel
05/16/2015

In dieser exemplarischen Vorgehensweise werden zwei Optionsseiten im Menü Extras eine einfache Seite und einer benutzerdefinierten Seite. Die einfache Seite verwendet ein Eigenschaftenraster, um Eigenschaften zu überprüfen und festzulegen, und die benutzerdefinierte Seite stellt eine eigene Benutzeroberfläche. Das verwaltete Paketframework (MPF) unterstützt beide Szenarien sehr mit kleinem zusätzlichen Code.

Um diese Eigenschaften zu speichern und sie über eine Einstellungsdatei wiederherzustellen, führen Sie die folgenden Schritte aus, und sehen Sie Exemplarische Vorgehensweise: Eine Einstellungskategorie erstellen.

Das MPF stellt zwei Klassen, mit denen Sie Optionsseiten im Menü Extras die Package-Klasse und die DialogPage-Klasse zu erstellen. Sie erstellen ein VSPackage, um einen Container für diese Seiten des Unterordnen der Paket Klasse bereitzustellen. Erstellen Sie die einzelnen Tools optionsseite, indem Sie von der DialogPage-Klasse berechnen.

In dieser exemplarischen Vorgehensweise erstellen Sie die Optionsseiten im Menü Extras und verwenden sie, um Optionen für die Anzeige und Änderungsübernahme. Sie rufen die Optionswerte von der verwaltenden VSPackage ab. Sie rufen sie programmgesteuert aus einem anderen VSPackage ab, indem Sie verwenden.

Vorbereitungsmaßnahmen

Zum Abschließen dieser exemplarischen Vorgehensweise müssen Sie Visual Studio 2010 SDKinstallieren.

Hinweis

Weitere Informationen über das Visual Studio-SDK finden Sie unter Erweitern von Visual Studio Overview.Um herauszufinden finden Sie unter wie das Visual Studio-SDK, auf Visual Studio Extensibility Developer Center der MSDN-Website herunterlädt.

Speicherorte für die Visual Studio-Paket-Projektvorlage

Die Visual Studio-Paket importieren kann in drei verschiedenen Stellen im Dialogfeld Neues Projekt gefunden werden:

Klicken Sie unter Von Visual Basic-Erweiterbarkeit. Die Standardsprache des Projekts ist Visual Basic.
Die C#-Erweiterbarkeit. Die Standardsprache ist C# des Projekts.
Verwenden anderer Projekttyp-Erweiterbarkeit. Die Standardsprache des Projekts ist C++.

Eine Tool-Options-Raster-Seite erstellen

In diesem Abschnitt verwenden Sie die Visual Studio Paket importieren, um ein einfaches Raster Eigenschaft Optionen zu erstellen. Mit diesem Raster, um den Wert einer Eigenschaft anzuzeigen und zu ändern.

So erstellen VSPackage-Projekt

Erstellen Sie ein neues Projekt mit dem Namen MyToolsOptionsVisual Studio Paket.

Weitere Informationen zum Erstellen eines verwalteten VSPackages finden Sie unter Exemplarische Vorgehensweise: Wenn Sie einen Menübefehl mit der Visual Studio-Paket-Vorlage erstellenerstellt.
Wählen Sie eine Programmiersprache aus. Klicken Sie auf der Seite ausgewählten Visual Basic oder Visual C#.
Wählen Sie auf der Seite Optionen für das VSPackage auswählenMenübefehl.
Ändern Sie auf der Seite BefehlsoptionenBefehlsname zu Rufen Sie internes Option VB ab oder Rufen Sie interne Option CS ab für Visual Basic oder Visual C# , legen Sie Befehls-ID jeweils zu cmdidGetIntOptfest, und klicken Sie dann auf Fertig stellen.

Um das Raster erstellen Eigenschaft Optionen

Öffnen Sie die MyToolsOptionsPackage-Datei im Code-Editor.

Fügen Sie die folgenden Namespaceverweise hinzu.

Imports System.ComponentModel

using System.ComponentModel;

Deklarieren Sie eine OptionPageGrid-Klasse, und leiten Sie diese von DialogPage.

Public Class OptionPageGrid
    Inherits DialogPage

public class OptionPageGrid : DialogPage

Wenden Sie ClassInterfaceAttribute zur OptionPageGrid-Klasse:

<ClassInterface(ClassInterfaceType.AutoDual)>
<CLSCompliant(False), ComVisible(True)>
Public Class OptionPageGrid
    Inherits DialogPage

[ClassInterface(ClassInterfaceType.AutoDual)]
[CLSCompliant(false), ComVisible(true)]
public class OptionPageGrid : DialogPage

Dadurch wird eine COM-duale Schnittstelle, die Visual Studio Automatisierung GetAutomationObject verwenden können, die öffentlichen Member der Klasse programmgesteuert zuzugreifen.

Wenden Sie ProvideOptionPageAttribute von der Klasse zur VSPackage-Klasse Optionen Kategorie und Optionsseiten Namen für OptionPageGridzuzuordnen.

<PackageRegistration(UseManagedResourcesOnly:=True),
InstalledProductRegistration("#110", "#112", "1.0", IconResourceID:=400),
ProvideMenuResource("Menus.ctmenu", 1),
Guid(GuidList.guidMyToolsOptionsPkgString)>
<ProvideOptionPage(GetType(OptionPageGrid),
    "My Category", "My Grid Page", 0, 0, True)>
Public NotInheritable Class MyToolsOptionsPackage
    Inherits Package

[PackageRegistration(UseManagedResourcesOnly = true),
InstalledProductRegistration("#110", "#112", "1.0", IconResourceID = 400),
ProvideMenuResource("Menus.ctmenu", 1),
Guid(GuidList.guidMyToolsOptionsPkgString)]
[ProvideOptionPage(typeof(OptionPageGrid),
    "My Category", "My Grid Page", 0, 0, true)]
public sealed class MyToolsOptionsPackage : Package

Hinweis

Sie können die Kategorie suchen, indem Sie Ressourcen-ID der Attributeigenschaft CategoryResourceIDzuweisen.

Fügen Sie eine OptionInteger-Eigenschaft der OptionPageGrid-Klasse hinzu.

Wenden Sie CategoryAttribute , um zur Kategorie Eigenschaftenraster eine Eigenschaft zuzuweisen.
Wenden Sie DisplayNameAttribute , um der Eigenschaft einen Namen zuzuordnen.
Wenden Sie DescriptionAttribute , um eine Beschreibung der Eigenschaft zugewiesen werden sollen.

<ClassInterface(ClassInterfaceType.AutoDual)>
<CLSCompliant(False), ComVisible(True)>
Public Class OptionPageGrid
    Inherits DialogPage

    Private optionValue As Integer = 256

    <Category("My Category")>
    <DisplayName("My Option Integer")>
    <Description("My integer option")>
    Public Property OptionInteger() As Integer 
        Get 
            Return optionValue
        End Get 
        Set(ByVal value As Integer)
            optionValue = value
        End Set 
    End Property 
End Class

[ClassInterface(ClassInterfaceType.AutoDual)]
[CLSCompliant(false), ComVisible(true)]
public class OptionPageGrid : DialogPage
{
    private int optionValue = 256;

    [Category("My Category")]
    [DisplayName("My Integer Option")]
    [Description("My integer option")]
    public int OptionInteger
    {
        get { return optionValue; }
        set { optionValue = value; }
    }
}

Hinweis

Die Standardimplementierung von DialogPage unterstützt Eigenschaften, die entsprechende Konverter haben oder die Strukturen oder Arrays sind Eigenschaften, die erweitert werden können, die entsprechende Konverter haben.Eine Liste von Konvertern finden Sie im System.ComponentModel-Namespace.Visual Studio-Erweiterbarkeits-Beispiele verwalteten int, stringund System.Drawing.Size-Eigenschaften.

Erstellen und Starten Sie das Projekt im Debugmodus, indem Sie F5 drücken. Dadurch wird Visual Studio in der experimentellen Hiven.

Hinweis

Beide Versionen von Visual Studio sind jetzt geöffnet.
In Visual Studioauf dem Extras Menü auf Optionen.

Das Optionen Dialog Box wird geöffnet.
Erweitern Sie in der Strukturansicht Meine Kategorie und klicken Sie dann auf Meine Rasterseite.

Das Raster Optionen wird im rechten Bereich angezeigt. Die Eigenschaft ist Meine OptionenKategorie und der Eigenschaftenname ist MeineOption Integer. Die Eigenschaftenbeschreibung, Meine ganzzahlige Option, wird am unteren Rand des Bereichs.

Ändern Sie den Wert der Anfangswert von 256 etwas Anderes an. Klicken Sie auf OKund öffnen Sie dann Meine Rasterseite. Sie können sehen, dass der neue Wert beibehalten wird.
Beenden Visual Studio Exp.

Eine Tool-Options-Gewohnheits-Seite erstellen

In diesem Abschnitt erstellen Sie eine Tools Options Pages with a Custom User Interface. Verwenden Sie diese Seite, um den Wert einer Eigenschaft anzuzeigen und zu ändern.

So erstellen Sie eine benutzerdefinierte Seite Optionen

Öffnen Sie die MyToolsOptionsPackage-Datei im Code-Editor.

Fügen Sie die folgenden Namespaces hinzu. Statement

Imports System.Windows.Forms

using System.Windows.Forms;

Fügen Sie eine OptionPageCustom-Klasse, kurz vor der OptionPageGrid-Klasse hinzu. Berechnen Sie die neue Klasse von DialogPage.
```
Public Class OptionPageCustom
    Inherits DialogPage
```
```
public class OptionPageCustom : DialogPage
```

Zeigen Sie im Menü Extras Klicken Sie auf GUID erstellen zum Kopieren und Einfügen eines neuen GUID mit Registrierungsformat in den Code und die geschweiften Klammern entfernen. Fügen Sie eine ClassInterfaceAttribute-Eigenschaft hinzu. Fügen Sie die Zeichenfolgeneigenschaft, OptionStringhinzu. Beachten Sie, dass in diesem Beispiel die GUID des GUIDs aufgeführt:

<ClassInterface(ClassInterfaceType.AutoDual),
Guid("42C7F4D9-200D-4fe2-A093-49AFA2DDE7F8")>
Public Class OptionPageCustom
    Inherits DialogPage

    Private optionValue As String = "alpha" 

    Public Property OptionString() As String 
        Get 
            Return optionValue
        End Get 
        Set(ByVal value As String)
            optionValue = value
        End Set 
    End Property 
End Class

[ClassInterface(ClassInterfaceType.AutoDual)]
[Guid("1D9ECCF3-5D2F-4112-9B25-264596873DC9")]
public class OptionPageCustom : DialogPage
{
    private string optionValue = "alpha";

    public string OptionString
    {
        get { return optionValue; }
        set { optionValue = value; }
    }
}

Wenden Sie ProvideOptionPageAttribute zur VSPackage-Klasse. Dadurch wird der Klasse Optionen Kategorie und Optionsseite benennen.

<PackageRegistration(UseManagedResourcesOnly:=True),
InstalledProductRegistration("#110", "#112", "1.0", IconResourceID:=400),
ProvideMenuResource("Menus.ctmenu", 1),
Guid(GuidList.guidMyToolsOptionsPkgString)>
<ProvideOptionPage(GetType(OptionPageCustom),
    "My Category", "My Custom Page", 0, 0, True)>
<ProvideOptionPage(GetType(OptionPageGrid),
    "My Category", "My Grid Page", 0, 0, True)>
Public NotInheritable Class MyToolsOptionsPackage
    Inherits Package

[PackageRegistration(UseManagedResourcesOnly = true),
InstalledProductRegistration("#110", "#112", "1.0", IconResourceID = 400),
ProvideMenuResource("Menus.ctmenu", 1),
Guid(GuidList.guidMyToolsOptionsPkgString)]
[ProvideOptionPage(typeof(OptionPageCustom),
    "My Category", "My Custom Page", 0, 0, true)]
[ProvideOptionPage(typeof(OptionPageGrid),
    "My Category", "My Grid Page", 0, 0, true)]
public sealed class MyToolsOptionsPackage : Package

Fügen Sie ein Benutzersteuerelement hinzu, das MyUserControl dem Projekt.

Das Benutzersteuerelement wird in der Entwurfsansicht.

Hinweis

Wenn Sie eine Warnung angezeigt wird, erstellen Sie die Projektmappe neu, und öffnen Sie MyUserControl.cs.Hierbei handelt es sich um ein bekanntes Problem.
Fügen Sie dem Benutzersteuerelement ein TextBox-Steuerelement hinzu. Im Eigenschaften Fenster auf der Symbolleiste auf die Schaltfläche Ereignisse doppelklicken, und klicken Sie dann auf das Verlassen-Ereignis.

Der Code-Editor wird geöffnet, um den neuen Ereignishandler anzuzeigen.

Fügen Sie ein öffentliches Feld OptionsPage eine Initialize-Methode zur Steuerelementklasse hinzu, und aktualisieren Sie den Text des Ereignishandlers wie folgt:

Public Class MyUserControl
    Friend optionsPage As OptionPageCustom

    Public Sub Initialize()
        TextBox1.Text = optionsPage.OptionString
    End Sub 

    Private Sub TextBox1_Leave(ByVal sender As Object, ByVal e As EventArgs) _
        Handles TextBox1.Leave
        optionsPage.OptionString = TextBox1.Text
    End Sub 
End Class

public partial class MyUserControl : UserControl
{
    public MyUserControl()
    {
        InitializeComponent();
    }

    internal OptionPageCustom optionsPage;

    public void Initialize()
    {
        textBox1.Text = optionsPage.OptionString;
    }

    private void textBox1_Leave(object sender, EventArgs e)
    {
        optionsPage.OptionString = textBox1.Text;
    }
}

Das optionsPage Feld behält einen Verweis auf die Elemente OptionPageCustom-Instanz an. Die Initialize-Methode wird OptionString in TextBoxan. Der Ereignishandler schreibt OptionString den aktuellen Wert TextBoxTextBox, wenn der Fokus verliert.

Fügen Sie in der Codedatei für das Paket eine Überschreibung für die OptionPageCustom.Window-Eigenschaft der OptionPageCustom-Klasse hinzu, um zu erstellen, und geben Sie initialisieren Sie eine Instanz von MyUserControlzurück. Beachten Sie folgendes Beispiel:

<Browsable(False)>
<DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)>
Protected Overrides ReadOnly Property Window() As IWin32Window
    Get 
        Dim page As New MyUserControl()
        page.optionsPage = Me
        page.Initialize()
        Return page
    End Get 
End Property

[Browsable(false)]
[DesignerSerializationVisibility(
    DesignerSerializationVisibility.Hidden)]
protected override IWin32Window Window
{
    get
    {
        MyUserControl page = new MyUserControl();
        page.optionsPage = this;
        page.Initialize();
        return page;
    }
}

Erstellen und Starten Sie das Projekt im Debugmodus, indem Sie F5 drücken. Dadurch wird eine neue Visual Studio Instanz.

Hinweis

Beide Versionen von Visual Studio sind an diesem Punkt geöffnet.
In der neuen Visual Studio Instanz Extras klicken Sie auf das Menü, und klicken Sie dann auf Optionen.

Das Optionen Dialog Box wird geöffnet.
Klicken Sie in der Strukturansicht Erweitern Sie im linken Bereich Meine Kategorie und klicken Sie dann auf Meine benutzerdefinierte Seite.
Ändern Sie den Wert von OptionString vom Startwert (Alpha, um etwas Anderes. Klicken Sie auf OKund öffnen Sie dann Meine benutzerdefinierte Seite. Sie können sehen, dass der neue Wert beibehalten wurde.
Schließen Sie die neue Visual StudioInstanz.

Zugreifen auf einem VSPackage der verwaltenden Optionen

In diesem Abschnitt erhalten Sie eine Option der Wert des VSPackage Hosts die zugehörige Tools Options Pages. Die gleiche Verfahren kann verwendet werden, um den Wert einer öffentlichen Eigenschaft.

So greifen Sie eine Option aus der verwaltenden VSPackage

In der Paketdatei ersetzen Sie den Text der MyToolsOptions.MenuItemCallback-Methode durch die folgenden Zeilen:

Private Sub MenuItemCallback(ByVal sender As Object, ByVal e As EventArgs)
    Dim page As OptionPageGrid = CType(GetDialogPage(GetType(OptionPageGrid)), OptionPageGrid)
    MessageBox.Show(String.Format(CultureInfo.CurrentCulture,
        "OptionInteger: {0}", page.OptionInteger))
End Sub

private void MenuItemCallback(object sender, EventArgs e)
{
    OptionPageGrid page =
        (OptionPageGrid)GetDialogPage(typeof(OptionPageGrid));
    MessageBox.Show(string.Format(CultureInfo.CurrentCulture,
        "OptionInteger: {0}", page.OptionInteger));
}

Dieser Code ruft GetDialogPage auf, um eine OptionPageGrid-Instanz zu erstellen oder abzurufen. OptionPageGrid ruft wiederum LoadSettingsFromStorage auf, um die Optionen zu laden, die öffentlichen Eigenschaften sind.

Erstellen und Starten Sie das Projekt im Debugmodus, indem Sie die Tastenkombination F5 drücken. Dadurch wird eine neue Instanz von Visual Studio.

Hinweis

Beide Versionen von Visual Studio sind an diesem Punkt geöffnet.
Zeigen Sie im Menü Extras Klicken Sie auf Interne Option abrufen.

Ein Meldungsfeld zeigt den aktuellen Wert von OptionIntegeran.
Beenden Sie die neue Visual StudioInstanz.

Optionen zugreifen durch Automatisierung

In diesem Abschnitt verwenden Sie die Automatisierung, um eine Option der Wert von einem VSPackage oder vom Add-In abzurufen. Die gleiche Verfahren kann verwendet werden, um den Wert einer öffentlichen Eigenschaft.

So erstellen Sie eine Option mit der Automatisierung zugreifen

Klicken Sie mit der rechten Maustaste auf die MyToolsOptions-Projektmappe in Projektmappen-Explorer , und fügen Sie ein neues Projekt mit dem Namen AnotherPackage Visual Studio Paket hinzu.

Weitere Informationen zum Erstellen eines verwalteten VSPackages finden Sie unter Exemplarische Vorgehensweise: Wenn Sie einen Menübefehl mit der Visual Studio-Paket-Vorlage erstellenerstellt.
In der Wählen Sie eine Programmiersprache aus. Seite in ausgewählten Visual Basic oder Visual C#.
In der Optionen für das VSPackage auswählen Seite wählen Sie Menübefehl.
In der Befehlsoptionen Seite ändern Sie Befehlsname externe abrufen „Option“, und klicken Sie dann auf Fertig stellen.

Die Vorlage erstellt das verwaltete Projekt, AnotherPackage.
Klicken Sie mit der rechten Maustaste auf AnotherPackage-Projektknoten, und klicken Sie dann auf Als Startprojekt festlegen.
Fügen Sie die folgenden Namespaceverweise auf die VsPkg-Codedatei im AnotherPackage-Projekt hinzu:
```
Imports EnvDTE
Imports System.Windows.Forms
```
```
using EnvDTE;
using System.Windows.Forms;
```

Ersetzen Sie den Text der AnotherPackage.MenuItemCallback-Methode durch die folgenden Zeilen:

Private Sub MenuItemCallback(ByVal sender As Object, ByVal e As EventArgs)
    Dim env As DTE = CType(GetService(GetType(DTE)), DTE)

    Dim props As EnvDTE.Properties = env.Properties("My Category", "My Grid Page")

    Dim value As Integer = CInt(props.Item("OptionInteger").Value)
    MessageBox.Show("OptionInteger: " & value.ToString())
End Sub

private void MenuItemCallback(object sender, EventArgs e)
{
    DTE env = (DTE)GetService(typeof(DTE));

    EnvDTE.Properties props =
        env.get_Properties("My Category", "My Grid Page");

    int n = (int)props.Item("OptionInteger").Value;
    MessageBox.Show("OptionInteger: " + n);
}

Dieser Code ruft einen Dienst an, das abgerufen DTE-Objekt das Stammobjekt des Automatisierungsmodells Visual Studio . Properties gibt die Eigenschaftenauflistung für My Category.MyGridPagezurück, die alle öffentlichen Eigenschaften enthält. Die Item-Methode wählt OptionInteger aus der Auflistung.

Erstellen und Starten Sie das Projekt im Debugmodus, indem Sie die Tastenkombination F5 drücken. Dadurch wird eine neue Instanz von Visual Studio.

Hinweis

Beide Versionen von Visual Studio sind an diesem Punkt geöffnet.
Zeigen Sie im Menü Extras Klicken Sie auf Externe Option abrufen.

Ein Meldungsfeld zeigt den aktuellen Wert von OptionIntegeran.

Freigeben über

Exemplarische Vorgehensweise: Eine Optionsseite erstellen

Vorbereitungsmaßnahmen

Speicherorte für die Visual Studio-Paket-Projektvorlage

Eine Tool-Options-Raster-Seite erstellen

So erstellen VSPackage-Projekt

Um das Raster erstellen Eigenschaft Optionen

Eine Tool-Options-Gewohnheits-Seite erstellen

So erstellen Sie eine benutzerdefinierte Seite Optionen

Zugreifen auf einem VSPackage der verwaltenden Optionen

So greifen Sie eine Option aus der verwaltenden VSPackage

Optionen zugreifen durch Automatisierung

So erstellen Sie eine Option mit der Automatisierung zugreifen

Siehe auch

Konzepte

Weitere Ressourcen

Zusätzliche Ressourcen