Procédure pas - à - pas : créer une page d'options

Article
05/17/2015

Cette procédure pas - à - pas crée deux pages options Outils, une page simple et une page personnalisée. La page simple utilise une grille de propriétés pour examiner et définir les propriétés, et la page personnalisée utilise sa propre interface utilisateur (UI). Managed package (MPF) prend en charge les deux cas, au code supplémentaire très petit.

Pour enregistrer ces propriétés les valeurs et les restaurer à partir d'un fichier de paramètres, suivez ces étapes, puis consultez le Procédure pas - à - pas : créer une catégorie de paramètres.

Le MPF fournit deux classes pour vous aider à créer des pages options Outils, la classe d' Package et la classe d' DialogPage . Vous créez un VSPackage pour fournir un conteneur pour ces pages par sous-classement la classe du package. Vous créez chaque page d'options d'outils en dérivant de la classe de DialogPage.

Dans cette procédure pas - à - pas, vous créez des pages options Outils et utilisez elles pour afficher les options et d'application des modifications. Vous récupérez les valeurs d'option du VSPackage hébergement. Vous les extraire par programme d'un autre VSPackage à l'aide de l'automation.

Composants requis

Pour exécuter cette procédure, vous devez installer Kit de développement logiciel Visual Studio 2010.

Notes

Pour plus d'informations sur le kit de développement Visual Studio, consultez Étendre la présentation de Visual Studio.Pour savoir comment télécharger le kit de développement Visual Studio, consultez Visual Studio Extensibility Developer Center sur le site Web MSDN.

Emplacements du modèle de projet de package Visual Studio

Le modèle de projet de package Visual Studio se trouve dans trois emplacements différents dans la boîte de dialogue Nouveau projet :

Sous l'extensibilité Visual Basic. Le langage par défaut du projet est en Visual Basic.
Sous l'extensibilité c#. Le langage par défaut du projet est c#.
Sous d'autres projets contenus l'extensibilité. Le langage par défaut du projet est en C++.

Créer une grille des options d'outils

Dans cette section, vous utilisez le modèle de projet package de Visual Studio pour créer une grille de propriétés simple d'options d'outils. vous utilisez cette grille pour afficher et modifier la valeur d'une propriété.

pour créer le projet de VSPackage

créez un nouveau package MyToolsOptionsnommé par projet de Visual Studio .

Pour plus d'informations sur la création d'un VSPackage managé, consultez Procédure pas - à - pas : Créer une commande de menu à l'aide de le modèle de package Visual Studio.
Dans la page de Sélectionner un langage de programmation , sélectionnez Visual Basic ou Visual C#.
Dans la page de Sélectionnez les options d'un VSPackage , sélectionnez Commande de menu.
Sur la page d' options de commande , modifiez nom de la commande à Option interne VB get ou CS interne d'option get pour Visual Basic ou Visual C# respectivement, définissez ID de commande à cmdidGetIntOpt, puis cliquez sur Terminer.

Pour créer la grille des propriétés des options d'outils

ouvrez le fichier de MyToolsOptionsPackage dans l'éditeur de code.

Ajoutez des références d'espace de noms suivantes.

Imports System.ComponentModel

using System.ComponentModel;

Déclarez une classe de OptionPageGrid et dérivez-la d' DialogPage.

Public Class OptionPageGrid
    Inherits DialogPage

public class OptionPageGrid : DialogPage

Appliquez ClassInterfaceAttribute à la classe d' OptionPageGrid :

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

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

Cela crée une interface double COM qui permet l'utilisation GetAutomationObject automation de Visual Studio d'accéder aux membres publics de la classe par programme.

Appliquez ProvideOptionPageAttribute à la classe d'un VSPackage à assigner à la classe des options catégorie et le nom de la page d'options pour OptionPageGrid.

<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

Notes

vous pouvez localiser la catégorie en assignant un ID de ressource à la propriété CategoryResourceIDd'attribut.

ajoutez une propriété d' OptionInteger à la classe d' OptionPageGrid .

Appliquez CategoryAttribute à attribuer à la propriété une catégorie de grille des propriétés.
Appliquez DisplayNameAttribute à attribuer à la propriété un nom.
Appliquez DescriptionAttribute à attribuer à la propriété une description.

<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; }
    }
}

Notes

L'implémentation par défaut d' DialogPage prend en charge les propriétés qui ont des convertisseurs appropriés ou qui sont des structures ou des tableaux peuvent être développées dans des propriétés possédant les convertisseurs appropriés.Pour obtenir la liste des convertisseurs, consultez l'espace de noms d' System.ComponentModel .Exemples d'extensibilité Visual Studio gère int, string, les propriétés et d' System.Drawing.Size .

Générez et exécutez le projet en mode débogage en appuyant sur F5. Cette action démarre Visual Studio dans la ruche expérimentale.

Notes

les deux versions de Visual Studio sont ouvertes maintenant.
Dans Visual Studio, sur le bouton Optionsde menu d' Outils .

La boîte de dialogue d' Options s'ouvre.
Dans l'arborescence, développez ma catégorie puis cliquez sur Ma grille.

La grille options s'affiche dans le volet droit. la catégorie de propriété est mes options, et le nom de la propriété est Myentier d'option. La description de la propriété, mon option entière, apparaît en bas du volet.

Remplacez la valeur de sa valeur initiale de 256 à d'autres éléments. Cliquez sur OK, puis rouvrez Ma grille. Vous pouvez voir que la nouvelle valeur est conservée.
sortie Visual Studio Exp.

Créer une page personnalisée des options d'outils

Dans cette section, vous créez une page d'options Outils avec une interface utilisateur personnalisée. Vous utilisez cette page pour afficher et de modifier la valeur d'une propriété.

Pour créer une page personnalisée des options d'outils

ouvrez le fichier de MyToolsOptionsPackage dans l'éditeur de code.

ajoutez l'instruction suivante de l'espace de noms.

Imports System.Windows.Forms

using System.Windows.Forms;

ajoutez une classe d' OptionPageCustom , juste avant la classe d' OptionPageGrid . Dérivez la classe d' DialogPage.
```
Public Class OptionPageCustom
    Inherits DialogPage
```
```
public class OptionPageCustom : DialogPage
```

Dans le menu d' Outils , cliquez sur Create GUID pour copier et coller un nouveau GUID avec le format de Registre dans le code, supprimant l'accolade. Ajoutez un ClassInterfaceAttribute ajoutez la propriété de type chaîne, OptionString. Notez que votre GUID est différent du GUID dans l'exemple :

<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; }
    }
}

Appliquez ProvideOptionPageAttribute à la classe d'un VSPackage. Cela assigne à la classe des options catégorie et la page d'options nom.

<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

ajoutez un contrôle utilisateur nommé MyUserControl au projet.

Le contrôle utilisateur s'ouvre en mode Design.

Notes

Si vous consultez un avertissement, régénérez la solution et rouvrez MyUserControl.cs.Il s'agit d'un problème connu.
ajoutez un contrôle de TextBox au contrôle utilisateur. Dans la fenêtre de Propriétés , dans la barre d'outils, cliquez sur le bouton d' Événements , puis double-cliquez sur l'événement de Conservez .

L'éditeur de code s'ouvre pour afficher le nouveau gestionnaire d'événements.

Ajoutez un champ public d' OptionsPage , une méthode d' Initialize à la classe de contrôle, puis mettez à jour le corps du gestionnaire d'événements comme suit :

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;
    }
}

Le champ d' optionsPage contient une référence à l'instance parente d' OptionPageCustom . la méthode d' Initialize affiche OptionString dans TextBox. Le gestionnaire d'événements écrit la valeur actuelle de TextBox à OptionString lorsque le focus quitte TextBox.

Dans le fichier de code de package, ajoutez une substitution pour la propriété d' OptionPageCustom.Window à la classe d'OptionPageCustom pour créer, l'initialisation, et retourner une instance d' MyUserControl. Voici un exemple :

<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;
    }
}

Générez et exécutez le projet en mode débogage en appuyant sur F5. Cette action démarre une nouvelle instance de Visual Studio.

Notes

les deux versions de Visual Studio sont ouvertes à ce stade.
Dans la nouvelle instance de Visual Studio, cliquez sur le menu d' Outils puis cliquez sur Options.

La boîte de dialogue d' Options s'ouvre.
Dans l'arborescence dans le volet gauche, développez ma catégorie puis cliquez sur ma page personnalisée.
Modifiez la valeur d' OptionString de sa valeur initiale, alpha, à d'autres éléments. Cliquez sur OK, puis rouvrez ma page personnalisée. Vous pouvez voir que la nouvelle valeur a été conservée.
Fermez la nouvelle instance de Visual Studio.

Options de accès du VSPackage hébergement

Dans cette section, vous obtenez la valeur d'une option de VSPackage qui héberge la page d'options Outils associée. La même technique peut être utilisée pour obtenir la valeur de toute propriété publique.

Pour accéder à une option de VSPackage hébergement

dans le fichier de package, remplacez le corps de la méthode d' MyToolsOptions.MenuItemCallback par les lignes suivantes :

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));
}

Ce code appelle GetDialogPage pour créer ou récupérer une instance d' OptionPageGrid . OptionPageGrid appelle à son tour LoadSettingsFromStorage pour charger ses options, qui sont des propriétés publiques.

Générez et exécutez le projet en mode débogage en appuyant sur le raccourci clavier, F5. Cette action démarre une nouvelle instance de Visual Studio.

Notes

les deux versions de Visual Studio sont ouvertes à ce stade.
Dans le menu d' Outils , cliquez sur Option interne get.

Un message affiche la valeur actuelle d' OptionInteger.
quittez la nouvelle instance de Visual Studio.

Options de accès en utilisant l'automation

Dans cette section, vous utilisez l'automation pour obtenir la valeur d'une option de tout VSPackage ou du complément. La même technique peut être utilisée pour obtenir la valeur de toute propriété publique.

Pour accéder à un élément à l'aide de automation

Cliquez avec le bouton droit sur la solution de MyToolsOptions dans Explorateur de solutions et ajoutez un nouveau package AnotherPackage nommé par projet de Visual Studio .

Pour plus d'informations sur la création d'un VSPackage managé, consultez Procédure pas - à - pas : Créer une commande de menu à l'aide de le modèle de package Visual Studio.
dans la page de Sélectionner un langage de programmation , sélectionnez Visual Basic ou Visual C#.
dans la page de Sélectionnez les options d'un VSPackage , sélectionnez Commande de menu.
Dans la page d' options de commande , modifiez Nom de commande « pour obtenir l'option externe », puis cliquez sur Terminer.

le modèle crée le projet managé, AnotherPackage.
Cliquez avec le bouton droit sur le nœud du projet d'AnotherPackage puis cliquez sur Définir comme projet de démarrage.
Ajoutez des références d'espace de noms suivantes au fichier de code de VsPkg dans le projet d'AnotherPackage :
```
Imports EnvDTE
Imports System.Windows.Forms
```
```
using EnvDTE;
using System.Windows.Forms;
```

remplacez le corps de la méthode d' AnotherPackage.MenuItemCallback par les lignes suivantes :

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);
}

ce code appelle un service pour obtenir l'objet d' DTE , l'objet racine du modèle Automation de Visual Studio . Properties retourne la collection de propriétés pour My Category.MyGridPage, qui comprend toutes les propriétés publiques. la méthode d' Item sélectionne OptionInteger de la collection.

Générez et exécutez le projet en mode débogage en appuyant sur le raccourci clavier, F5. Cette action démarre une nouvelle instance de Visual Studio.

Notes

les deux versions de Visual Studio sont ouvertes à ce stade.
Dans le menu d' Outils , cliquez sur Option externe get.

Un message affiche la valeur actuelle d' OptionInteger.

Partager via

Procédure pas - à - pas : créer une page d'options

Composants requis

Emplacements du modèle de projet de package Visual Studio

Créer une grille des options d'outils

pour créer le projet de VSPackage

Pour créer la grille des propriétés des options d'outils

Créer une page personnalisée des options d'outils

Pour créer une page personnalisée des options d'outils

Options de accès du VSPackage hébergement

Pour accéder à une option de VSPackage hébergement

Options de accès en utilisant l'automation

Pour accéder à un élément à l'aide de automation

Voir aussi

Concepts

Autres ressources

Ressources supplémentaires