Creare una pagina di opzioni

Articolo
12/15/2023

Questa procedura dettagliata crea una semplice pagina Strumenti/Opzioni che usa una griglia delle proprietà per esaminare e impostare le proprietà.

Per salvare queste proprietà in e ripristinarle da un file di impostazioni, seguire questa procedura e quindi vedere Creare una categoria di impostazioni.

MPF fornisce due classi che consentono di creare pagine Opzioni strumenti, la Package classe e la DialogPage classe . Si crea un PACCHETTO VSPackage per fornire un contenitore per queste pagine sottoclassando la Package classe . È possibile creare ogni pagina delle opzioni degli strumenti derivando dalla DialogPage classe .

Creare una pagina della griglia Opzioni strumenti

In questa sezione viene creata una semplice griglia delle proprietà Opzioni strumenti. Questa griglia viene usata per visualizzare e modificare il valore di una proprietà.

Per creare il progetto VSIX e aggiungere un PACCHETTO VSPackage

Ogni estensione di Visual Studio inizia con un progetto di distribuzione VSIX, che conterrà gli asset di estensione. Creare un progetto VSIX di Visual Studio denominato MyToolsOptionsExtension. È possibile trovare il modello di progetto VSIX nella finestra di dialogo Nuovo progetto cercando "vsix".
Aggiungere un pacchetto VSPackage aggiungendo un modello di elemento del pacchetto di Visual Studio denominato MyToolsOptionsPackage. Nella Esplora soluzioni fare clic con il pulsante destro del mouse sul nodo del progetto e scegliere Aggiungi>nuovo elemento. Nella finestra di dialogo Aggiungi nuovo elemento passare a Visual C# Items Extensibility (Estendibilità elementi>di Visual C#) e selezionare Visual Studio Package (Pacchetto di Visual Studio). Nel campo Nome nella parte inferiore della finestra di dialogo modificare il nome del file in MyToolsOptionsPackage.cs. Per altre informazioni su come creare un pacchetto VSPackage, vedere Creare un'estensione con un pacchetto VSPackage.

Per creare la griglia delle proprietà Opzioni strumenti

Aprire il file MyToolsOptionsPackage nell'editor di codice.
Aggiungere l'istruzione using seguente.
```
using System.ComponentModel;
```
Dichiarare una OptionPageGrid classe e derivarla da DialogPage.
```
public class OptionPageGrid : DialogPage
{  }
```

Applicare un ProvideOptionPageAttribute oggetto alla VSPackage classe per assegnare alla classe un nome di pagina di opzioni e categoria di opzioni per OptionPageGrid. Il risultato deve avere un aspetto simile al seguente:

[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

Aggiungere una OptionInteger proprietà alla OptionPageGrid classe .
- Applicare un System.ComponentModel.CategoryAttribute oggetto per assegnare alla proprietà una categoria della griglia delle proprietà.
- Applicare un System.ComponentModel.DisplayNameAttribute oggetto per assegnare alla proprietà un nome.
- Applicare un System.ComponentModel.DescriptionAttribute oggetto per assegnare alla proprietà una descrizione.
```
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; }
    }
}
```
Nota

L'implementazione predefinita di DialogPage supporta proprietà con convertitori appropriati o strutture o matrici che possono essere espanse in proprietà con convertitori appropriati. Per un elenco dei convertitori, vedere lo System.ComponentModel spazio dei nomi .
Compilare il progetto e avviare il debug.
Nell'istanza sperimentale di Visual Studio scegliere Opzioni dal menu Strumenti.

Nel riquadro sinistro dovrebbe essere visualizzato My Category (Categoria personale). Le categorie di opzioni sono elencate in ordine alfabetico, quindi dovrebbero essere visualizzate a metà dell'elenco. Aprire My Category (Categoria personale) e quindi fare clic su My Grid Page (Pagina Griglia personale). La griglia delle opzioni viene visualizzata nel riquadro destro. La categoria di proprietà è My Options e il nome della proprietà è My Integer Option.The property category is My Options, and the property name is My Integer Option. La descrizione della proprietà, opzione Numero intero, viene visualizzata nella parte inferiore del riquadro. Modificare il valore dal valore iniziale 256 a qualcos'altro. Fare clic su OK e quindi riaprire la pagina Griglia personale. È possibile notare che il nuovo valore persiste.

La pagina delle opzioni è disponibile anche tramite la casella di ricerca di Visual Studio. Nella casella di ricerca nella parte superiore dell'IDE digitare My Category ( Categoria personale-> Pagina griglia personale) elencata nei risultati.

Creare una pagina personalizzata Opzioni strumenti

In questa sezione viene creata una pagina Opzioni strumenti con un'interfaccia utente personalizzata. Utilizzare questa pagina per visualizzare e modificare il valore di una proprietà.

Aprire il file MyToolsOptionsPackage nell'editor di codice.
Aggiungere l'istruzione using seguente.
```
using System.Windows.Forms;
```

Aggiungere una OptionPageCustom classe, subito prima della OptionPageGrid classe . Derivare la nuova classe da DialogPage.

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

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

Aggiungere un attributo GUID. Aggiungere una proprietà OptionString:

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

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

Applicare un secondo ProvideOptionPageAttribute alla classe VSPackage. Questo attributo assegna alla classe un nome di pagina di opzioni e una categoria di opzioni.

[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

Aggiungere un nuovo controllo utente denominato MyUserControl al progetto.
Aggiungere un controllo TextBox al controllo utente.

Nella finestra Proprietà fare clic sul pulsante Eventi sulla barra degli strumenti e quindi fare doppio clic sull'evento Leave. Il nuovo gestore eventi viene visualizzato nel codice MyUserControl.cs .
Aggiungere un campo pubblico OptionsPage , un Initialize metodo alla classe del controllo e aggiornare il gestore eventi per impostare il valore dell'opzione sul contenuto della casella di testo:
```
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;
    }
}
```
Il optionsPage campo contiene un riferimento all'istanza padre OptionPageCustom . Il Initialize metodo viene visualizzato OptionString nel controllo TextBox. Il gestore eventi scrive il valore corrente di TextBox nell'oggetto OptionString quando lo stato attivo lascia textBox.

Nel file di codice del pacchetto aggiungere un override per la OptionPageCustom.Window proprietà alla OptionPageCustom classe per creare, inizializzare e restituire un'istanza di MyUserControl. A questo punto, la classe dovrebbe apparire come illustrato di seguito:

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

Compilare ed eseguire il progetto.
Nell'istanza sperimentale fare clic su Opzioni strumenti>.
Trovare My Category (Categoria personale) e quindi My Custom Page (Pagina personalizzata).
Modificare il valore di OptionString. Fare clic su OK e quindi riaprire la pagina personalizzata. Si noterà che il nuovo valore è persistente.

Opzioni di accesso

In questa sezione si ottiene il valore di un'opzione dal PACCHETTO VSPackage che ospita la pagina Opzioni strumenti associata. La stessa tecnica può essere usata per ottenere il valore di qualsiasi proprietà pubblica.

Nel file di codice del pacchetto aggiungere una proprietà pubblica denominata OptionInteger alla classe MyToolsOptionsPackage .
```
public int OptionInteger
{
    get
    {
        OptionPageGrid page = (OptionPageGrid)GetDialogPage(typeof(OptionPageGrid));
        return page.OptionInteger;
    }
}
```
Questo codice chiama GetDialogPage per creare o recuperare un'istanza OptionPageGrid . OptionPageGrid chiama LoadSettingsFromStorage per caricare le relative opzioni, ovvero proprietà pubbliche.
Aggiungere ora un modello di elemento di comando personalizzato denominato MyToolsOptionsCommand per visualizzare il valore. Nella finestra di dialogo Aggiungi nuovo elemento passare a Visual C#>Estendibilità e selezionare Comando personalizzato. Nel campo Nome nella parte inferiore della finestra modificare il nome del file di comando in MyToolsOptionsCommand.cs.

Nel file MyToolsOptionsCommand sostituire il corpo del metodo del ShowMessageBox comando con quanto segue:

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

Compilare il progetto e avviare il debug.
Nell'istanza sperimentale scegliere Richiama MyToolsOptionsCommand dal menu Strumenti.

In una finestra di messaggio viene visualizzato il valore corrente di OptionInteger.

Aprire la pagina delle opzioni

In questa sezione si aggiungeranno un comando e un evento per il pulsante per aprire la pagina delle opzioni

Aggiungere innanzitutto un file denominato OpenPageCommand.cs.

Aprire quindi OpenPageCommand.cs e modificare il metodo Execute.

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

Eseguire il progetto, quindi fare clic sul pulsante Richiama (si trova sotto l'opzione Strumento per impostazione predefinita), quindi è possibile visualizzare la pagina delle opzioni aperta.
Per altre informazioni sull'apertura della pagina delle opzioni, vedere i documenti seguenti

Apertura di una pagina di opzioni

Opzioni e pagine di opzioni