Share via

Erstellen einer Optionsseite

  • Artikel

In dieser exemplarischen Vorgehensweise wird eine einfache Seite "Extras/Optionen" erstellt, auf der ein Eigenschaftenraster zum Untersuchen und Festlegen von Eigenschaften verwendet wird.

Um diese Eigenschaften in einer Einstellungsdatei zu speichern und sie aus einer Einstellungsdatei wiederherzustellen, führen Sie die folgenden Schritte aus, und lesen Sie dann "Erstellen einer Einstellungskategorie".

Der MPF stellt zwei Klassen bereit, die Ihnen beim Erstellen von Tools options pages, the Package class and the DialogPage class helfen. Sie erstellen ein VSPackage, um einen Container für diese Seiten bereitzustellen, indem Sie die Package Klasse unterklassen. Sie erstellen jede Tools-Optionsseite, indem Sie von der DialogPage Klasse abgeleitet werden.

Seite "Extras-Optionen" erstellen

In diesem Abschnitt erstellen Sie ein einfaches Eigenschaftenraster "Extras-Optionen". Mit diesem Raster können Sie den Wert einer Eigenschaft anzeigen und ändern.

So erstellen Sie das VSIX-Projekt und fügen ein VSPackage hinzu

  1. Jede Visual Studio-Erweiterung beginnt mit einem VSIX-Bereitstellungsprojekt, das die Erweiterungsressourcen enthält. Erstellen Sie ein Visual Studio VSIX-Projekt mit dem Namen MyToolsOptionsExtension. Sie finden die VSIX-Projektvorlage im Dialogfeld "Neues Projekt ", indem Sie nach "vsix" suchen.

  2. Fügen Sie eine VSPackage hinzu, indem Sie eine Visual Studio-Paketelementvorlage mit dem Namen MyToolsOptionsPackagehinzufügen. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektknoten, und wählen Sie Hinzufügen>Neues Element aus. Wechseln Sie im Dialogfeld "Neues Element hinzufügen" zur Erweiterbarkeit von Visual C#-Elementen>, und wählen Sie "Visual Studio-Paket" aus. Ändern Sie im Feld "Name " unten im Dialogfeld den Dateinamen in MyToolsOptionsPackage.cs. Weitere Informationen zum Erstellen eines VSPackage-Elements finden Sie unter Erstellen einer Erweiterung mit einem VSPackage.

So erstellen Sie das Eigenschaftenraster "Extrasoptionen"

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

  2. Fügen Sie die folgende using-Anweisung hinzu.

    using System.ComponentModel;

  3. Deklarieren Sie eine OptionPageGrid Klasse, und leiten Sie sie von DialogPage.

    public class OptionPageGrid : DialogPage
{  }

  4. Wenden Sie eine ProvideOptionPageAttribute auf die VSPackage Klasse an, um der Klasse einen Optionskategorie- und Optionsseitennamen für das OptionPageGrid zuzuweisen. Das Ergebnis sollte wie folgt aussehen:

    [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

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

    public class OptionPageGrid : DialogPage
{
    private int optionInt = 256;

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

    Hinweis

    Die Standardimplementierung unterstützt DialogPage Eigenschaften mit geeigneten Konvertern oder Strukturen oder Arrays, die in Eigenschaften mit entsprechenden Konvertern erweitert werden können. Eine Liste der Konverter finden Sie im System.ComponentModel Namespace.

  6. Erstellen Sie das Projekt, und starten Sie das Debugging.

  7. Klicken Sie in der experimentellen Instanz von Visual Studio im Menü "Extras " auf "Optionen".

    Im linken Bereich sollte "Meine Kategorie" angezeigt werden. (Optionskategorien werden in alphabetischer Reihenfolge aufgeführt, daher sollte sie ungefähr in der Hälfte der Liste angezeigt werden.) Öffnen Sie "Meine Kategorie ", und klicken Sie dann auf "Meine Rasterseite". Das Optionsraster wird im rechten Bereich angezeigt. Die Eigenschaftskategorie ist "Meine Optionen", und der Eigenschaftsname ist "My Integer Option". Die Eigenschaftsbeschreibung, Option "Meine ganze Zahl", wird unten im Bereich angezeigt. Ändern Sie den Wert von 256 in einen anderen Wert. Klicken Sie auf "OK", und öffnen Sie dann "Meine Rasterseite" erneut. Sie können sehen, dass der neue Wert beibehalten wird.

    Ihre Optionsseite ist auch über das Suchfeld von Visual Studio verfügbar. Geben Sie im Suchfeld oben in der IDE "Meine Kategorie" ein, und in den Ergebnissen wird "Meine Kategorie> " Meine Rasterseite" aufgelistet.

Erstellen einer benutzerdefinierten Seite "Extrasoptionen"

In diesem Abschnitt erstellen Sie eine Seite "Extras-Optionen" mit einer benutzerdefinierten Benutzeroberfläche. Sie verwenden diese Seite, um den Wert einer Eigenschaft anzuzeigen und zu ändern.

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

  2. Fügen Sie die folgende using-Anweisung hinzu.

    using System.Windows.Forms;

  3. Fügen Sie einen OptionPageCustom Kurs direkt vor dem OptionPageGrid Kurs hinzu. Leiten Sie die neue Klasse von DialogPage.

    public class OptionPageCustom : DialogPage
{
    private string optionValue = "alpha";

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

  4. Fügen Sie ein GUID-Attribut hinzu. Hinzufügen einer OptionString-Eigenschaft:

    [Guid("00000000-0000-0000-0000-000000000000")]
public class OptionPageCustom : DialogPage
{
    private string optionValue = "alpha";

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

  5. Wenden Sie eine Sekunde ProvideOptionPageAttribute auf die VSPackage-Klasse an. Dieses Attribut weist der Klasse einen Optionskategorie- und Optionsseitennamen zu.

    [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)]
[ProvideOptionPage(typeof(OptionPageCustom),
    "My Category", "My Custom Page", 0, 0, true)]
public sealed class MyToolsOptionsPackage : Package

  6. Fügen Sie dem Projekt ein neues Benutzersteuerelement mit dem Namen "MyUserControl" hinzu.

  7. Fügen Sie dem Benutzersteuerelement ein TextBox-Steuerelement hinzu.

    Klicken Sie im Eigenschaftenfenster auf der Symbolleiste auf die Schaltfläche "Ereignisse ", und doppelklicken Sie dann auf das Leave-Ereignis . Der neue Ereignishandler wird im Code "MyUserControl.cs " angezeigt.

  8. Fügen Sie der Steuerelementklasse ein öffentliches OptionsPage Feld, eine Initialize Methode hinzu, und aktualisieren Sie den Ereignishandler, um den Optionswert auf den Inhalt des Textfelds festzulegen:

    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 enthält einen Verweis auf die übergeordnete OptionPageCustom Instanz. Die Initialize Methode wird im TextBox-Steuerelement angezeigtOptionString. Der Ereignishandler schreibt den aktuellen Wert des TextBox-Steuerelements in den OptionString Fall, wenn der Fokus das TextBox-Objekt verlässt.

  9. Fügen Sie in der Paketcodedatei der Klasse eine Außerkraftsetzung für die OptionPageCustom.WindowOptionPageCustom Eigenschaft hinzu, um eine Instanz von MyUserControlzu erstellen, zu initialisieren und zurückzugeben. Die -Klasse müsste jetzt wie folgt aussehen:

    [Guid("00000000-0000-0000-0000-000000000000")]
public class OptionPageCustom : DialogPage
{
    private string optionValue = "alpha";

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

    protected override IWin32Window Window
    {
        get
        {
            MyUserControl page = new MyUserControl();
            page.optionsPage = this;
            page.Initialize();
            return page;
        }
    }
}

  10. Erstellen Sie das Projekt, und führen Sie es aus.

  11. Klicken Sie in der experimentellen Instanz auf "Extras>Optionen".

  12. Suchen Sie "Meine Kategorie " und dann " Meine benutzerdefinierte Seite".

  13. Ändern Sie den Wert von OptionString. Klicken Sie auf "OK", und öffnen Sie dann "Meine benutzerdefinierte Seite" erneut. Sie können sehen, dass der neue Wert beibehalten wurde.

Zugriffsoptionen

In diesem Abschnitt erhalten Sie den Wert einer Option aus dem VSPackage, das die zugehörige Seite "Tools-Optionen" hosten soll. Die gleiche Technik kann verwendet werden, um den Wert einer beliebigen öffentlichen Eigenschaft abzurufen.

  1. Fügen Sie in der Paketcodedatei der MyToolsOptionsPackage-Klasse eine öffentliche Eigenschaft namens OptionInteger hinzu.

    public int OptionInteger
{
    get
    {
        OptionPageGrid page = (OptionPageGrid)GetDialogPage(typeof(OptionPageGrid));
        return page.OptionInteger;
    }
}

    Dieser Code ruft zum Erstellen oder Abrufen einer Instanz auf GetDialogPageOptionPageGrid . OptionPageGrid Aufrufe LoadSettingsFromStorage zum Laden der Optionen, bei denen es sich um öffentliche Eigenschaften handelt.

  2. Fügen Sie nun eine benutzerdefinierte Befehlselementvorlage namens "MyToolsOptionsCommand " hinzu, um den Wert anzuzeigen. Wechseln Sie im Dialogfeld "Neues Element hinzufügen" zu Visual C#>Erweiterbarkeit, und wählen Sie "Benutzerdefinierter Befehl" aus. Ändern Sie im Feld "Name " unten im Fenster den Befehlsdateinamen in "MyToolsOptionsCommand.cs".

  3. Ersetzen Sie in der Datei "MyToolsOptionsCommand " den Textkörper der Methode des ShowMessageBox Befehls durch Folgendes:

    private void ShowMessageBox(object sender, EventArgs e)
{
    MyToolsOptionsPackage myToolsOptionsPackage = this.package as MyToolsOptionsPackage;
    System.Windows.Forms.MessageBox.Show(string.Format(CultureInfo.CurrentCulture, "OptionInteger: {0}", myToolsOptionsPackage.OptionInteger));
}

  4. Erstellen Sie das Projekt, und starten Sie das Debugging.

  5. Klicken Sie in der experimentellen Instanz im Menü "Extras " auf " MyToolsOptionsCommand aufrufen".

    Ein Meldungsfeld zeigt den aktuellen Wert von OptionInteger.

Seite "Optionen öffnen"

In diesem Abschnitt fügen Sie einen Befehl und ein Ereignis für die Schaltfläche hinzu, um die Optionsseite zu öffnen.

  1. Fügen Sie zuerst eine Datei namens "OpenPageCommand.cs" hinzu.

  2. Öffnen Sie dann OpenPageCommand.cs , und ändern Sie die Execute-Methode.

    private void Execute(object sender, EventArgs e)
{
    ThreadHelper.ThrowIfNotOnUIThread();
    Type optionsPageType = typeof(OptionPageCustom);
    Instance.package.ShowOptionPage(optionsPageType);
}

  3. Führen Sie das Projekt aus, und klicken Sie dann auf die Schaltfläche "Aufrufen" (standardmäßig unter der Option "Tool"), und Dann wird die Optionsseite geöffnet.

  4. Weitere Details zur Seite "Öffnen von Optionen" finden Sie in den folgenden Dokumenten.

Zugehöriger Inhalt