Passo a passo: Criando uma página de opções

Esta explicação passo a passo cria duas páginas de opções de ferramentas, uma página simples e uma página personalizada. A página simple usa uma grade de propriedade para examinar e definir propriedades e a página personalizada fornece sua própria interface de usuário (UI). A estrutura de pacote gerenciado (MPF) oferece suporte a ambos os cenários, com muito pouco código adicional.

Para salvar essas propriedades para e restaurá-los a partir de um arquivo de configurações, siga estas etapas e, em seguida, consulte Passo a passo: Criando uma categoria de configurações.

O MPF fornece duas classes para ajudá-lo a criar páginas de opções de ferramentas, o Package classe e o DialogPage classe. Você cria um VSPackage para fornecer um recipiente para essas páginas através de subclasses da classe do pacote. Você pode criar cada página de opções de ferramentas, derivando da classe DialogPage.

Nesta explicação, você pode cria as páginas de opções de ferramentas e usá-las para exibir e alterar as opções de aplicativo. Você pode recuperar os valores de opção do VSPackage de hospedagem. Você recuperá-los por meio de programação de outro VSPackage usando automação.

Pré-requisitos

Para concluir este passo a passo, você deve instalar o SDL do Visual Studio 2010.

Dica

Para obter mais informações sobre o SDK de Visual Studio, consulte Ampliando a visão geral de Visual Studio.Para descobrir como fazer o download do SDK do Visual Studio, consulte Visual Studio extensibilidade Developer Center no site do MSDN.

Locais para o modelo de projeto de pacote de Visual Studio

O modelo de projeto do pacote de Visual Studio pode ser encontrado em três locais diferentes de Novo projeto caixa de diálogo:

1. Em Visual Basic extensibilidade. O idioma padrão do projeto é Visual Basic.

2. Em C# extensibilidade. O idioma padrão do projeto é C#.

3. Em outra extensibilidade de tipos de projeto. O idioma padrão do projeto é C++.

Criando uma página de grade de opções de ferramentas

Nesta seção, você usa o Visual Studio modelo de projeto de pacote para criar uma grade de propriedade de opções de ferramentas simple. Você pode usar essa grade para exibir e alterar o valor de uma propriedade.

Para criar o projeto VSPackage

1. Criar uma nova Visual Studio o projeto do pacote chamado MyToolsOptions.

   Para obter mais informações sobre como criar um VSPackage gerenciado, consulte Passo a passo: Criando um comando de Menu usando o modelo de pacote de Visual Studio.

2. Sobre o Select a Programming Language , selecione Visual Basic ou Visual C#.

3. Sobre o Selecionar opções de VSPackage , selecione Comando de Menu.

4. No Opções de comando de página, alterar o nome do comando para obter opção interna VB ou obter opção interna CS para Visual Basic ou Visual C# respectivamente, defina a ID do comando para cmdidGetIntOpte, em seguida, clique em Concluir.

Para criar a grade de propriedades de opções de ferramentas

1. Abra o arquivo de MyToolsOptionsPackage no editor de código.

2. Adicione as seguintes referências do namespace.

   Imports System.ComponentModel
   

   using System.ComponentModel;
   

3. Declara uma classe OptionPageGrid e derivam de DialogPage.

   Public Class OptionPageGrid
       Inherits DialogPage
   

   public class OptionPageGrid : DialogPage
   

4. Aplicar uma ClassInterfaceAttribute para o OptionPageGrid classe:

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

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

   Isso cria uma interface COM dupla que permite que Visual Studio o uso de automação GetAutomationObject para acessar membros públicos da classe programaticamente.

5. Aplicar uma ProvideOptionPageAttribute à classe VSPackage para atribuir à classe de uma categoria de opções e o nome da página de opções para o 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
   

   Dica

   Você pode localizar a categoria, atribuindo uma identificação de recurso para a propriedade do atributo CategoryResourceID.

6. Adicionar um OptionInteger propriedade para o OptionPageGrid classe.

   • Aplicar uma CategoryAttribute para atribuir à propriedade de uma categoria de grade de propriedade.

   • Aplicar uma DisplayNameAttribute para atribuir à propriedade um nome.

   • Aplicar uma DescriptionAttribute para atribuir à propriedade de uma descrição.

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

   Dica

   A implementação padrão do DialogPage oferece suporte para propriedades que possuem conversores apropriados ou que são estruturas ou arrays que podem ser expandidos para propriedades que possuem conversores apropriados.Para obter uma lista dos conversores, consulte o System.ComponentModel espaço para nome.The Exemplos de extensibilidade de Visual Studio manages int, string, and System.Drawing.Size properties.

7. Criar e iniciar o projeto no modo de depuração pressionando F5. Isso inicia Visual Studio no hive experimental.

   Dica

   As duas versões do Visual Studio agora estão abertos.

8. Na Visual Studiodiante do Ferramentas menu do botão Opções de.

   O Opções abre a caixa de diálogo.

9. Na exibição em árvore, expanda Categoria Meus e, em seguida, clique em Minha página de grade.

   A grade de opções é exibida no painel à direita. A categoria de propriedade é Minhas opções, e o nome da propriedade é MinhasOpção inteiro. A descrição da propriedade, minha opção inteiro, aparece na parte inferior do painel.

   Altere o valor de seu valor inicial de 256 para outra coisa. Clique em OKe em seguida, reabra Minha página de grade. Você pode ver que o novo valor persiste.

10. Exit Visual Studio Exp.

Criando uma página de personalizado de opções de ferramentas

Nesta seção, você pode criar uma página de opções de ferramentas com uma interface de usuário personalizada. Use esta página para exibir e alterar o valor de uma propriedade.

Para criar uma página de opções de ferramentas personalizada

1. Abra o arquivo de MyToolsOptionsPackage no editor de código.

2. Adicione a seguinte instrução de namespace.

   Imports System.Windows.Forms
   

   using System.Windows.Forms;
   

3. Adicionar um OptionPageCustom de classe, antes de OptionPageGrid classe. Derivar a nova classe de DialogPage.

   Public Class OptionPageCustom
       Inherits DialogPage
   

   public class OptionPageCustom : DialogPage
   

4. Sobre o Ferramentas menu, clique em Criar GUID para copiar e colar um novo GUID com o formato do registro no código, removendo as chaves. Acrescente um ClassInterfaceAttribute. Adicione a propriedade de cadeia de caracteres, OptionString. Observe que o GUID será diferente do GUID no exemplo:

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

5. Aplicar uma ProvideOptionPageAttribute à classe VSPackage. Isso irá atribuir a classe de uma categoria de opções e o nome da página de opções.

   <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
   

6. Adicione um controle de usuário chamado MyUserControl ao projeto.

   O controle de usuário é aberto no modo Design.

   Dica

   Se você vir um aviso, recrie a solução e reabra o MyUserControl.cs.Este é um problema conhecido.

7. Adicionar um caixa de texto controle para o controle de usuário. No Propriedades janela, na barra de ferramentas, clique no eventos botão e, em seguida, clique duas vezes o deixar evento.

   O editor de código é aberto para mostrar o novo manipulador de eventos.

8. Adicionar um relatório público OptionsPage campo, um Initialize método para a classe de controle e a atualização do corpo do manipulador de eventos da seguinte maneira:

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

   O optionsPage campo contém uma referência ao pai do OptionPageCustom instância. O Initialize método exibe OptionString na caixa de texto. O manipulador de eventos grava o valor atual do caixa de texto para o OptionString ao focalizar deixa o TextBox.

9. No arquivo de pacote de código, adicione uma substituição para o OptionPageCustom.Window propriedade à classe OptionPageCustom para criar, inicializar e retornar uma instância de MyUserControl. A seguir, há um exemplo:

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

10. Criar e iniciar o projeto no modo de depuração pressionando F5. Isso inicia um novo Visual Studio instância.

    Dica

    As duas versões do Visual Studio estão abertos neste momento.

11. Nos novos Visual Studio da instância, clique no Ferramentas menu e clique Opções de.

    O Opções abre a caixa de diálogo.

12. Na exibição em árvore no painel esquerdo, expanda Categoria Meus e, em seguida, clique em Minha página personalizada.

13. Alterar o valor de OptionString do seu valor inicial, alfa para outra coisa. Clique em OKe em seguida, reabra Minha página personalizada. Você pode ver que o novo valor se manteve.

14. Feche o novo Visual Studio instância.

Acessando opções a partir de hospedagem VSPackage

Nesta seção, você obtém o valor de uma opção do VSPackage que hospeda a página de opções de ferramentas associada. A mesma técnica pode ser usada para obter o valor de qualquer propriedade pública.

Para acessar uma opção do VSPackage hospedagem

1. No arquivo do pacote, substitua o corpo da MyToolsOptions.MenuItemCallback método com as seguintes linhas:

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

   Este código chama GetDialogPage para criar ou recuperar um OptionPageGrid instância. OptionPageGridpor sua vez chama LoadSettingsFromStorage para carregar suas opções, que são propriedades públicas.

2. Criar e iniciar o projeto no modo de depuração pressionando o atalho de teclado, F5. Isso inicia uma nova instância do Visual Studio.

   Dica

   As duas versões do Visual Studio estão abertos neste momento.

3. Sobre o Ferramentas menu, clique em obter opção interna.

   Uma caixa de mensagem exibe o valor atual de OptionInteger.

4. Sair do novo Visual Studio instância.

Acessando opções por meio de automação

Nesta seção, você usa a automação para obter o valor de uma opção de qualquer VSPackage ou suplemento. A mesma técnica pode ser usada para obter o valor de qualquer propriedade pública.

Para acessar uma opção usando a automação

1. Clique com o botão direito a solução de MyToolsOptions Solution Explorer e adicione um novo Visual Studio project de pacote denominado AnotherPackage.

   Para obter mais informações sobre como criar um VSPackage gerenciado, consulte Passo a passo: Criando um comando de Menu usando o modelo de pacote de Visual Studio.

2. No Select a Programming Language , selecione Visual Basic ou Visual C#.

3. No Selecionar opções de VSPackage , selecione Comando de Menu.

4. No Opções de comando de página, alterar o Nome do comando "Get a opção externa" e depois clique em Concluir.

   O modelo cria um projeto gerenciado, AnotherPackage.

5. Clique com o botão direito no nó do projeto AnotherPackage e clique em Set as StartUp Project.

6. Adicione as seguintes referências de espaço para nome para o arquivo de código de VsPkg no projeto AnotherPackage:

   Imports EnvDTE
   Imports System.Windows.Forms
   

   using EnvDTE;
   using System.Windows.Forms;
   

7. Substituir o corpo da AnotherPackage.MenuItemCallback método com as seguintes linhas:

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

   Este código chama um serviço para obter o DTE objeto, o objeto raiz da Visual Studio modelo de automação. PropertiesRetorna a coleção de propriedades de My Category.MyGridPage, que inclui todas as propriedades públicas. O Item método seleciona OptionInteger da coleção.

8. Criar e iniciar o projeto no modo de depuração pressionando o atalho de teclado, F5. Isso inicia uma nova instância do Visual Studio.

   Dica

   As duas versões do Visual Studio estão abertos neste momento.

9. Sobre o Ferramentas menu, clique em obter opção externa.

   Uma caixa de mensagem exibe o valor atual de OptionInteger.

Consulte também

Conceitos

Suporte para páginas de opções

Outros recursos

Estado VSPackage