Perguntas frequentes: convertendo suplementos em extensões VSPackage

Artigo
06/10/2015

Suplementos agora são preteridos. Para criar uma nova extensão do Visual Studio é preciso criar um VSPackage. Se você já possuir um suplemento, ele ainda poderá ser executado, no entanto, se desejar distribuí-lo, será melhor converter em um VSPackage. Aqui estão as respostas para algumas perguntas frequentes sobre como converter um suplemento do Visual Studio em uma extensão VSPackage.

Importante

Em muitos casos, você pode simplesmente transferir o seu código de suplemento para um projeto do VSPackage.Você pode obter o objeto de automação DTE chamando GetService no método Initialize.

DTE2 dte = (DTE2)GetService(typeof(DTE));

Para obter mais informações, consulte Como posso executar o meu código de suplemento em um VSPackage? abaixo.

Qual software é necessário para desenvolver extensões VSPackage?

É necessário instalar o SDK do Visual Studio 2013 além da edição Professional, Premium ou Ultimate do Visual Studio 2013. É possível baixar o SDK na página do SDK do Visual Studio 2013 no site do Centro de Download da Microsoft. É recomendável instalar o SDK antes de instalar a Atualização 2 do Visual Studio 2013.

Onde está a documentação do VSPackage?

Comece com Ampliando a visão geral de Visual Studio. Outros artigos sobre desenvolvimento de VSPackage são organizados sob aquele.

É possível converter um projeto de suplemento em um projeto de VSPackage?

Não é possível converter um projeto de suplemento em um projeto de VSPackage porque os mecanismos usados em projetos de VSPackage não são os mesmos de projetos de suplemento. O modelo de projeto de VSPackage possui muito código que o torna relativamente fácil de configurar e executar como uma extensão de VSPackage.

O que fazer para começar a desenvolver extensões de VSPackage?

O modelo de projeto para extensões de VSPackage possui os elementos necessários. Aqui está como fazer um VSPackage que possui um comando de menu:

Crie um projeto de Visual Studio Package e nomeie-o TestVSPackage. (Arquivo, Novo, Projeto ou digite projeto na janela Início Rápido). Na caixa de diálogo Novo Projeto, expanda Outros Tipos de Projeto, Extensibilidade e selecione Visual Studio Package. Nomeie o projeto como TestVSPackage e especifique um local para ele.
O Assistente do Visual Studio Package é exibido. Na página Selecione uma linguagem de programação, selecione C# como linguagem. Mantenha a opção Gerar uma nova chave selecionada. Na página Opções do VSPackage, selecione Comando de Menu. Selecione o botão Concluir.
Pressione F5 para compilar e executar o projeto em modo de depuração.

Uma segunda instância do Visual Studio é exibida. A segunda instância é chamada de instância experimental e não poderá ter as mesmas configurações que a instância do Visual Studio que estiver usando para escrever código. Na primeira vez que executar a instância experimenta, será solicitado para entrar no VS Online e especificar o tema e o perfil.

No menu Ferramentas (na instância experimental) deverá haver um botão chamado Nome do Meu Comando. Ao escolher esse botão, uma mensagem deverá ser exibida: Dentro de TestVSPackagePackage.MenuItemCallback().

Como executar o código do suplemento em um VSPackage?

Código de suplemento geralmente é executado de uma entre duas maneiras:

Acionado por um comando de menu (o código está no método de IDTCommandTarget.Exec)
Automaticamente na inicialização (o código está no manipulador de eventos OnConnection.)

É possível fazer as mesmas coisas em um VSPackage. Aqui está como incluir um código de suplemento no método de retorno de chamada:

Criar VSPackage que possui um comando de menu. (Consulte Como posso iniciar o desenvolvimento de extensões do VSPackage?).
Abra o arquivo que contém a definição do VSPackage. (Em um projeto de C#, será <nome do projeto>Package.cs.)
Inclua as seguintes instruções using no arquivo:
```
using EnvDTE;
using EnvDTE80;
```
Encontre o método MenuItemCallback. Inclua uma chamada para GetService para obter o objeto DTE2:
```
DTE2 dte = (DTE2)GetService(typeof(DTE));
```

Inclua o código que o suplemento continha em seu método IDTCommandTarget.Exec. Por exemplo, aqui está um código que inclui um novo painel na janela Saída e exibe "Algum Texto" no novo painel.

private void MenuItemCallback(object sender, EventArgs e)
{
    DTE2 dte = (DTE2) GetService(typeof(DTE));
    OutputWindow outputWindow = dte.ToolWindows.OutputWindow;

    OutputWindowPane outputWindowPane = outputWindow.OutputWindowPanes.Add("A New Pane");
    outputWindowPane.OutputString("Some Text");
}

Compile e execute esse projeto. Pressione F5 ou selecione Iniciar na barra de ferramentas Depuração. Na instância experimental do Visual Studio, o menu Ferramentas deverá conter um botão chamado Nome do Meu Comando. Ao escolher esse botão, as palavras Algum Texto devem aparecer em um painel da janela Saída. (Poderá ser necessário abrir a janela Saída.)

Também é possível configurar a execução do código na inicialização. No entanto, essa abordagem geralmente é desencorajada para extensões de VSPackage. Se muitas extensões tentarem carregar na inicialização do Visual Studio, o tempo de inicialização poderá tornar-se notavelmente mais longo. Uma prática melhor é carregar o VSPackage automaticamente apenas quando alguma condição for atendida (como a abertura de uma solução).

Esse procedimento mostra como executar código de suplemento em um VSPackage que é carregado automaticamente quando uma solução for aberta:

Carregar um VSPackage automaticamente

Criar um projeto de Visual Studio Package. (Para obter as etapas para fazer isso, consulte Como inicio o desenvolvimento de extensões do VSPackage?. Nomeie o projeto como TestAutoload e especifique um local para ele.
O Assistente do Visual Studio Package é exibido. Na página Selecione uma linguagem de programação, selecione C# como linguagem e mantenha a opção Gerar uma nova chave selecionada. Escolha Concluir.
Abra TestAutoloadPackage.cs. Encontre a linha onde a classe do pacote é declarada:
```
public sealed class <name of your package>Package : Package
```
Acima dessa linha há um conjunto de atributos. Inclua este atributo:
```
[ProvideAutoLoad(UIContextGuids80.SolutionExists)]
```
Defina um ponto de interrupção no método Initialize() e inicie a depuração (F5).
Na instância experimental, abra um projeto. O VSPackage deverá ser carregado e o ponto de interrupção deverá ser atingido.

É possível especificar outros contextos nos quais carregará o VSPackage usando os campos de UIContextGuids80. Para obter mais informações, consulte Como: Autoload VSPackage.

Como obter o objeto DTE?

Se o suplemento não exibir a UI—por exemplo, comandos de menu, botões da barra de ferramentas ou janelas de ferramentas—você poderá usar o código no estado em que estiver desde que obtenha o objeto de automação DTE do VSPackage. Veja como:

Obter o objeto DTE de um VSPackage

Em uma solução de VSPackage, procure pelo arquivo <nome do projeto>Package.cs. Essa é a classe derivada de Package; poderá ajudar a interagir com o Visual Studio. Nesse caso, use o GetService para obter o objeto DTE2.
Inclua estas instruções using:
```
using EnvDTE;
using EnvDTE80;
```
Encontre o método Initialize. Esse método manipula o comando especificado no assistente de pacote. Inclua uma chamada para GetService para obter o objeto DTE:
```
DTE dte = (DTE)GetService(typeof(DTE));
```

Após ter o objeto de automação DTE, é possível incluir o restante do código de suplemento no projeto. Se o objeto DTE2 for necessário, é possível fazer a mesma coisa.

Extensões de VSPackage usam o arquivo .vsct para criar a maioria dos comandos de menu, barras de ferramentas, botões de barras de ferramentas e outras UI. O modelo de projeto VSPackage oferece a opção de criar um comando no menu Ferramentas. Para obter mais informações, consulte Passo a passo: Criando um comando de Menu usando o modelo de pacote de Visual Studio.

Para obter mais informações sobre os arquivos .vsct, consulte Como a VSPackages adicionar elementos de Interface do usuário ao IDE. Para obter explicações passo a passo que mostram como usar o arquivo .vsct para incluir itens de menu, barras de ferramentas e botões de barra de ferramentas, consulte Explicações passo a passo para comandos, Menus e barras de ferramentas

Como incluir janelas de ferramenta personalizadas da maneira do VSPackage?

O modelo de projeto VSPackage oferece a opção de criar uma janela de ferramenta. Para obter mais informações, consulte Janelas de ferramentas e os artigos contidos, especialmente Como: criar uma janela de ferramenta.

Como gerenciar janelas do Visual Studio da maneira do VSPackage?

Se o suplemento gerencia janelas do Visual Studio, o código do suplemento deverá funcionar em um VSPackage. Por exemplo, esse procedimento mostra como incluir código que gerencia a Lista de Tarefas no método MenuItemCallback do VSPackage.

Inserir código de gerenciamento de janelas a partir de um suplemento em um VSPackage

Crie um VSPackage que tenha um comando de menu, como na seção Como iniciar o desenvolvimento de extensões do VSPackage?.
Abra o arquivo que contém a definição do VSPackage. (Em um projeto de C#, será <nome do projeto>Package.cs.)
Inclua estas instruções using:
```
using EnvDTE;
using EnvDTE80;
```
Encontre o método MenuItemCallback. Inclua uma chamada para GetService para obter o objeto DTE2:
```
DTE2 dte = (DTE2)GetService(typeof(DTE));
```

Inclua o código do suplemento. Por exemplo, aqui está um código que inclui novas tarefas na Lista de Tarefas, lista o número de tarefas e exclui uma tarefa.

private void MenuItemCallback(object sender, EventArgs e) 
{
    DTE2 dte = (DTE2) GetService(typeof(DTE)); 

    TaskList tl = (TaskList)dte.ToolWindows.TaskList; 
    askItem tlItem; 

    // Add a couple of tasks to the Task List. 
    tlItem = tl.TaskItems.Add(" ", " ", "Test task 1.",  
        vsTaskPriority.vsTaskPriorityHigh, vsTaskIcon.vsTaskIconUser, 
        true, "", 10, true, true);
    tlItem = tl.TaskItems.Add(" ", " ", "Test task 2.", 
        vsTaskPriority.vsTaskPriorityLow, vsTaskIcon.vsTaskIconComment, true, "", 20, true,true);

    // List the total number of task list items after adding the new task items.
    System.Windows.Forms.MessageBox.Show("Task Item 1 description: "+tl.TaskItems.Item(2).Description);
    System.Windows.Forms.MessageBox.Show("Total number of task items: "+tl.TaskItems.Count); 

    // Remove the second task item. The items list in reverse numeric order. 
    System.Windows.Forms.MessageBox.Show("Deleting the second task item");
    tl.TaskItems.Item(2).Delete();
    System.Windows.Forms.MessageBox.Show("Total number of task items: "+tl.TaskItems.Count); 
}

Como gerenciar projetos e soluções em um VSPackage?

Se o suplemento gerencia projetos e soluções, o código do suplemento deverá funcionar em um VSPackage. Por exemplo, esse procedimento mostra como incluir código que obtém o projeto de inicialização.

Crie um VSPackage que tenha um comando de menu, como na seção Como iniciar o desenvolvimento de extensões do VSPackage?.
Abra o arquivo que contém a definição do VSPackage. (Em um projeto de C#, será <nome do projeto>Package.cs.)
Inclua estas instruções using:
```
using EnvDTE;
using EnvDTE80;
```
Encontre o método MenuItemCallback. Inclua uma chamada para GetService para obter o objeto DTE2:
```
DTE2 dte = (DTE2)GetService(typeof(DTE));
```

Inclua o código do suplemento. Por exemplo, o código a seguir obtém o nome do projeto de inicialização em uma solução. (Um projeto multi-soluções deve estar aberto ao executar esse pacote.)

private void MenuItemCallback(object sender, EventArgs e)
{
    DTE2 dte = (DTE2) GetService(typeof(DTE)); 

    SolutionBuild2 sb = (SolutionBuild2)dte.Solution.SolutionBuild; 
    Project startupProj; 
    string msg = "";

    foreach (String item in (Array)sb.StartupProjects) 
    {
        msg += item; 
    }
    System.Windows.Forms.MessageBox.Show("Solution startup Project: "+msg); 
    startupProj = dte.Solution.Item(msg); 
    System.Windows.Forms.MessageBox.Show("Full name of solution's startup project: "+"/n"+startupProj.FullName); 
}

Como definir atalhos de teclado em um VSPackage?

Use o elemento <KeyBindings> do arquivo .vsct. No exemplo a seguir, o atalho de teclado para o comando idCommand1 é Alt+A e o atalho de teclado para o comando idCommand2 é Alt+Ctrl+A. Observe a sintaxe dos nomes das teclas.

<KeyBindings>
    <KeyBinding guid="MyProjectCmdSet" id="idCommand1" editor="guidVSStd97" key1="A" mod1="ALT" />
    <KeyBinding guid="MyProjectCmdSet" id="idCommand2" editor="guidVSStd97" key1="A" mod1="CONTROL" mod2="ALT" />
</KeyBindings>

Como manipular eventos de automação em um VSPackage?

Eventos de automação em um VSPackage são manipulados da mesma maneira que no suplemento. O código a seguir mostra como manipular o evento OnItemRenamed. (Este exemplo considera que você já obteve o objeto DTE.)

Events2 dteEvents = (Events2)dte.Events;
dteEvents.ProjectItemsEvents.ItemRenamed += listener1.OnItemRenamed; 
. . .
public void OnItemRenamed(EnvDTE.ProjectItem projItem, string oldName) 
{
    string s = "[Event] Renamed " + oldName + " to " + Path.GetFileName(projItem.get_FileNames(1) + " in project " + projItem.ContainingProject.Name; 
}

Share via