Compartir a través de

Crear una página de opciones

  • Artículo

En este tutorial se crea una página herramientas y opciones sencilla que usa una cuadrícula de propiedades para examinar y establecer propiedades.

Para guardar estas propiedades en un archivo de configuración y restaurarlas, siga estos pasos y, a continuación, vea Crear una categoría de configuración.

MPF proporciona dos clases para ayudarle a crear páginas de opciones de herramientas, la Package clase y la DialogPage clase . Puede crear un VSPackage para proporcionar un contenedor para estas páginas mediante la subclase de la Package clase . Puede crear cada página de opciones de herramientas derivando de la DialogPage clase .

Crear una página de cuadrícula Opciones de herramientas

En esta sección, creará una cuadrícula de propiedades de Opciones de herramientas sencilla. Esta cuadrícula se usa para mostrar y cambiar el valor de una propiedad.

Para crear el proyecto VSIX y agregar un VSPackage

  1. Cada extensión de Visual Studio comienza con un proyecto de implementación VSIX, que contendrá los recursos de extensión. Cree un proyecto VSIX de Visual Studio denominado MyToolsOptionsExtension. Puede encontrar la plantilla de proyecto VSIX en el cuadro de diálogo Nuevo proyecto buscando "vsix".

  2. Agregue un VSPackage agregando una plantilla de elemento paquete de Visual Studio denominada MyToolsOptionsPackage. En el Explorador de soluciones, haga clic con el botón derecho en el nodo del proyecto y seleccione Agregar>Nuevo elemento. En el cuadro de diálogo Agregar nuevo elemento, vaya a Extensibilidad de elementos>de Visual C# y seleccione Paquete de Visual Studio. En el campo Nombre de la parte inferior del cuadro de diálogo, cambie el nombre de archivo a MyToolsOptionsPackage.cs. Para obtener más información sobre cómo crear un VSPackage, consulte Creación de una extensión con un VSPackage.

Para crear la cuadrícula de propiedades Opciones de herramientas

  1. Abra el archivo MyToolsOptionsPackage en el editor de código.

  2. Agregue la siguiente instrucción using.

    using System.ComponentModel;

  3. Declare una OptionPageGrid clase y derive de DialogPage.

    public class OptionPageGrid : DialogPage
{  }

  4. Aplique a ProvideOptionPageAttribute la VSPackage clase para asignar a la clase un nombre de página de opciones y categoría de opciones para OptionPageGrid. El resultado debería tener el siguiente aspecto:

    [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. Agregue una OptionInteger propiedad a la OptionPageGrid clase .

    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:

    La implementación predeterminada de DialogPage admite propiedades que tienen convertidores adecuados o que son estructuras o matrices que se pueden expandir en propiedades que tienen convertidores adecuados. Para obtener una lista de convertidores, consulte el System.ComponentModel espacio de nombres .

  6. Compile la solución y comience la depuración.

  7. En la instancia experimental de Visual Studio, en el menú Herramientas , haga clic en Opciones.

    En el panel izquierdo, debería ver Mi categoría. (Las categorías de opciones se enumeran en orden alfabético, por lo que debe aparecer aproximadamente a mitad de la lista). Abra Mi categoría y, a continuación, haga clic en Mi página de cuadrícula. La cuadrícula de opciones aparece en el panel derecho. La categoría de propiedad es My Options y el nombre de la propiedad es My Integer Option. La descripción de la propiedad, mi entero, aparece en la parte inferior del panel. Cambie el valor de su valor inicial de 256 a otra cosa. Haga clic en Aceptar y, a continuación, vuelva a abrir mi página de cuadrícula. Puede ver que el nuevo valor persiste.

    La página de opciones también está disponible a través del cuadro de búsqueda de Visual Studio. En el cuadro de búsqueda situado cerca de la parte superior del IDE, escriba Mi categoría y verá Mi categoría -> Mi página de cuadrícula en los resultados.

Crear una página personalizada de opciones de herramientas

En esta sección, creará una página Opciones de herramientas con una interfaz de usuario personalizada. Esta página se usa para mostrar y cambiar el valor de una propiedad.

  1. Abra el archivo MyToolsOptionsPackage en el editor de código.

  2. Agregue la siguiente instrucción using.

    using System.Windows.Forms;

  3. Agregue una OptionPageCustom clase, justo antes de la OptionPageGrid clase . Derive la nueva clase de DialogPage.

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

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

  4. Agregue un atributo GUID. Agregue una propiedad OptionString:

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

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

  5. Aplique un segundo ProvideOptionPageAttribute a la clase VSPackage. Este atributo asigna a la clase un nombre de página de opciones y categoría de opciones.

    [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. Agregue un nuevo control de usuario denominado MyUserControl al proyecto.

  7. Agregue un control TextBox al control de usuario.

    En la ventana Propiedades , en la barra de herramientas, haga clic en el botón Eventos y, a continuación, haga doble clic en el evento Leave . El nuevo controlador de eventos aparece en el código MyUserControl.cs .

  8. Agregue un campo público OptionsPage , un Initialize método a la clase de control y actualice el controlador de eventos para establecer el valor de opción en el contenido del cuadro de texto:

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

    El optionsPage campo contiene una referencia a la instancia primaria OptionPageCustom . El Initialize método se muestra OptionString en textbox. El controlador de eventos escribe el valor actual de TextBox en cuando OptionString el foco sale de TextBox.

  9. En el archivo de código de paquete, agregue una invalidación para la OptionPageCustom.Window propiedad a la OptionPageCustom clase para crear, inicializar y devolver una instancia de MyUserControl. La clase ahora debería verse así:

    [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. Compile y ejecute el proyecto.

  11. En la instancia experimental, haga clic en Opciones de herramientas>.

  12. Busque Mi categoría y, a continuación, Mi página personalizada.

  13. Cambie el valor de OptionString. Haga clic en Aceptar y vuelva a abrir Mi página personalizada. Puede ver que el nuevo valor se ha conservado.

Opciones de acceso

En esta sección, obtendrá el valor de una opción de VSPackage que hospeda la página Opciones de herramientas asociada. La misma técnica se puede usar para obtener el valor de cualquier propiedad pública.

  1. En el archivo de código de paquete, agregue una propiedad pública denominada OptionInteger a la clase MyToolsOptionsPackage .

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

    Este código llama GetDialogPage a para crear o recuperar una OptionPageGrid instancia. OptionPageGrid llama LoadSettingsFromStorage a para cargar sus opciones, que son propiedades públicas.

  2. Ahora agregue una plantilla de elemento de comando personalizada denominada MyToolsOptionsCommand para mostrar el valor. En el cuadro de diálogo Agregar nuevo elemento, vaya a Visual C#>Extensibilidad y seleccione Comando personalizado. En el campo Nombre de la parte inferior de la ventana, cambie el nombre del archivo de comando a MyToolsOptionsCommand.cs.

  3. En el archivo MyToolsOptionsCommand , reemplace el cuerpo del método del ShowMessageBox comando por lo siguiente:

    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. Compile la solución y comience la depuración.

  5. En la instancia experimental, en el menú Herramientas , haga clic en Invocar MyToolsOptionsCommand.

    Un cuadro de mensaje muestra el valor actual de OptionInteger.

Página Abrir opciones

En esta sección, agregará un comando y un evento para el botón para abrir la página de opciones.

  1. En primer lugar, agregue un archivo denominado OpenPageCommand.cs.

  2. A continuación, abra OpenPageCommand.cs y cambie el método Execute.

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

  3. Ejecute el proyecto y, a continuación, haga clic en el botón Invocar (está debajo de la opción Herramienta de forma predeterminada) y, a continuación, puede ver que se abre la página de opciones.

  4. Puede consultar más detalles sobre la página de opciones de apertura a los siguientes documentos.

Contenido relacionado