ASP.NET

Artigo
06/04/2015

Crie seus próprios modelos do Visual Studio com SideWaffle

Agradecemos ao lançamento do novo Community Edition do Visual Studio, aos desenvolvedores acostumados com as edições Express no passado que agora podem usar as extensões das quais já ouviram falar muito. Caso você esteja se perguntando, extensões são plug-ins que podem ampliar a funcionalidade do Visual Studio. Há muitas extensões disponíveis.

Estamos sempre procurando maneiras para escrever código com mais eficiência e, há um ano atrás, encontramos uma extensão chamada SideWaffle (sidewaffle.com). A SideWaffle adiciona novo modelos de projeto e de item feitos por outros desenvolvedores para o Visual Studio e permite que você crie seus próprios modelos e trechos de código. Neste artigo, vamos dar uma olhada no SideWaffle e mostraremos como criar seus próprios modelos e trechos de código.

Por que usar o SideWaffle?

Como observado, o SideWaffle adiciona novos modelos de projeto e de item para o Visual Studio. Você deve estar se perguntando "Como isso me ajudaria"? Digamos que você é um desenvolvedor Web free-lance que desenvolve sites da Web para clientes. Você provavelmente tem coisas específicas que você repete para cada site, talvez usando uma biblioteca Java Script de terceiros como Knockout. js ou configurando uma estrutura de pastas de projeto específico. Não importa como você configura um projeto, o SideWaffle pode transformá-lo em um modelo reutilizável. Além disso, o SideWaffle inclui um pacote do NuGet reutilizável, TemplateBuilder, que cria modelos em extensões.

Criação de um pacote de modelo

Antes de criar um modelo, você precisa configurar o ambiente de desenvolvimento. O primeiro item que você precisa, é claro, é o Visual Studio. Neste artigo, nós usamos a Community Edition do Visual Studio 2013 (bit.ly/1GUTLo3). Em seguida, é necessário o SDK do Visual Studio 2013 (bit.ly/1NZVkD9). Por fim, baixe e instale a extensão de SideWaffle de sidewaffle.com.

Com todas as ferramentas instaladas e prontas para usar, comece abrindo o Visual Studio e criando um novo projeto. Há dois tipos de projetos que você pode usar para criar um pacote de modelo. O primeiro é um projeto VSPackage, que fornece a capacidade de adicionar recursos como menus de contexto ou itens de menu no Visual Studio. O segundo é um projeto VSIX, que é apenas um contêiner para armazenar arquivos de projeto e recursos e não fornece funcionalidade adicional. Você pode encontrar ambos na caixa de diálogo Novo projeto sob o nó Extensibilidade. Hoje, queremos apenas um modelo básico, de forma que um projeto VSIX funcionará. Você pode deixar o nome do projeto padrão.

Quando o projeto é criado, seu arquivo de manifesto será aberto automaticamente. O campo de autor é obrigatório, então adicione seu nome (ou o nome da empresa) aqui. A Descrição é o que será mostrado na caixa de diálogo de extensão do Visual Studio, então não se esqueça de adicionar algum texto útil. Em seguida, salve o arquivo e feche-o. A próxima etapa é adicionar o pacote TemplateBuilder NuGet ao projeto, que pode ser feito usando a caixa de diálogo Gerenciar Pacotes NuGet ou o Console de Gerenciamento de Pacotes.

Vamos parar por um segundo agora e dar uma olhada nos bastidores. Quando você instala o TemplateBuilder em um projeto, aqui está o que acontece:

Uma referência a TemplateBuilder.dll é adicionada. Esse assembly contém assistentes personalizados que podem ser usados durante o processo de criação do modelo, bem como outros auxiliares.
O arquivo de projeto é modificado para importar um arquivo de destinos MSBuild adicional, permitindo que o processo de compilação dê suporte a adição de modelos para o VSIX gerado. Como isso é implementado com o MSBuild, você pode criar sua extensão em servidores de integração contínua e a partir da linha de comando.
Um arquivo de propriedades é adicionado ao Properties\template builder.props. Você pode especificar o nome da folha padrão do nó que deve conter seus modelos. Você também pode usar esse arquivo para controlar aspectos específicos do TemplateBuilder.
O manifesto VSIX (normalmente chamado source.extension.vsixmanifest) é modificado para incluir marcas de Ativos para os modelos gerados.

Com o TemplateBuilder instalado, você pode iniciar a criação de modelos. Quando você compila o projeto do VSIX, o TemplateBuilder é ativado automaticamente e começa a processar os modelos.

A adição do TemplateBuilder ao projeto conclui todos os requisitos preliminares. Agora podemos adicionar o modelo de projeto à solução atualmente aberta.

Criando o primeiro modelo de projeto

Vamos usar um projeto existente, o que é um projeto de Formulários da web do Contoso ASP.NET/MVC genérico. Este projeto usa o Bootstrap 3, o jQuery e o Modernizr, que ajudarão a acelerar o desenvolvimento quando quisermos criar um novo projeto com base neste modelo. Como uma regra, é aconselhável executar primeiro qualquer projeto após adicioná-lo à solução. Isso é apenas uma precaução para certificar-se de que o projeto funcionará conforme o esperado antes de criar o modelo. Então, execute este projeto (Ctrl + F5) e verifique se ele está funcionando.

Para criar um modelo de projeto, você precisa fazer o seguinte:

Adicionar o projeto à solução e desativá-lo a partir da compilação.
Adicione uma referência de modelo para o projeto do VSIX.
Adicione arquivos de metadados para o projeto de origem para obter informações de modelo.

Para evitar que o projeto de modelo que está sendo criado mais pelo Visual Studio nesta solução (você ainda pode compilar e executar esse projeto em outras soluções), clique no menu suspenso para a configuração de compilação e selecione Gerenciador de configuração na lista. Isso abre a caixa de diálogo Gerenciador de configuração. Para evitar que o projeto que seja compilado, desmarque-o na coluna de compilação. Depois de fazer isso para a configuração de depuração, selecione a lista suspensa de configuração de solução ativa e repita o processo para a configuração da versão.

Pode demorar algum tempo quando desejar criar um modelo que contém vários projetos. Se você acaba trabalhando em um projeto complexo parecido e chegar a essa etapa, tenha em mente que a única coisa que deve ser verificada para as configurações de Depuração e Versão é o projeto do VSIX ou o projeto de VSPackage, dependendo do que você escolheu no início. Figura 1 mostra a janela Gerenciador de configuração depois de interromper o projeto que estava sendo compilado.

Figura 1 Desabilitar a compilação da Configuração de depuração

Em seguida, você conecta o projeto do VSIX ao projeto principal, o que será feito adicionando uma referência de modelo. Com o botão direito no projeto VSIX e selecione Adicionar | Adicionar referência de modelo (projeto SideWaffle) das opções.

Será exibida uma caixa de diálogo Seletor de projeto. Na lista, selecione o projeto que você deseja usar como modelo e clique em OK. Isso fará algumas alterações ao seu projeto do VSIX e você será solicitado a recarregar o projeto. Você pode selecionar a opção Recarregar todos e aguardar o SideWaffle concluir.

Agora, vamos adicionar os arquivos de metadados de modelo para o projeto da Web. Em seu projeto principal e selecione Adicionar | Novo Item entre as opções listadas. Na caixa de diálogo Adicionar Novo Item que aparece, vá para a seção Extensibilidade e selecione Arquivos de modelo de projeto do SideWaffle. Você pode usar o nome padrão fornecido pelo Visual Studio. Depois de selecionar o modelo de item de Arquivos de modelo de projeto, clique no botão Adicionar.

O item de arquivos de Modelo de projeto adiciona dois novos arquivos ao projeto principal. Primeiro, ele adiciona _preprocess.xml, que informa ao Visual Studio onde colocar seu modelo quando você abrir a caixa de diálogo Novo projeto. Este é o conteúdo padrão para esse arquivo:

<?xml version="1.0" encoding="utf-8" ?>
<Preprocess>
  <TemplateInfo Path="CSharp\Web\SideWaffle"/>
  <Replacements Include="*.*" Exclude="*.vstemplate;
    *.jpg;*.png;*.ico;_preprocess.xml;_project.vstemplate.xml">
    <add key="ContosoWebFormsMvc" value="$safeprojectname$"/>
  </Replacements>
</Preprocess>

Nesse arquivo, você encontrará as informações a seguir:

O caminho para o nó onde o modelo aparecerá na caixa de diálogo Novo projeto.
Informações sobre substituições de fonte.

O atributo de caminho no elemento de Modelo e Informações especifica o local onde o modelo aparecerá na caixa de diálogo Novo projeto.

Dentro do elemento Substituições, você pode declarar qualquer substituição que deve ser aplicada durante o processo de compilação do modelo. Você obtém uma substituição padrão para o nome do projeto que será substituído por $safeprojectname$ no modelo gerado. Isso atualizará normalmente declarações de namespace. Usando $safeprojectname$ quando o modelo é usado no Visual Studio, as declarações de namespace serão atualizadas com o nome especificado pelo usuário. Você não está limitado a uma substituição. Você pode adicionar tantas quantas forem necessárias. Às vezes, talvez seja necessário modificar fontes para fazer seleções exclusivas para que as substituições não entrem em conflito.

Agora, vamos passar para outro arquivo que foi adicionado ao projeto, _project.vstemplate.xml, que contém metadados sobre o modelo. A Figura 2 mostra o conteúdo padrão do arquivo, onde ContosoWebFormsMvc é o nome do projeto.

Figura 2 Um arquivo _project.vstemplate.xml genérico

<VSTemplate Version="3.0.0"
  xmlns="https://schemas.microsoft.com/developer/vstemplate/2005"
  Type="Project">
  <TemplateData>
    <Name>Your name here</Name>
    <Description>Project description here</Description>
    <DefaultName>ContosoWebFormsMvc</DefaultName>
    <ProjectType>CSharp</ProjectType>
    <ProjectSubType></ProjectSubType>
    <SortOrder>1000</SortOrder>
    <CreateNewFolder>true</CreateNewFolder>   
    <ProvideDefaultName>true</ProvideDefaultName>
    <LocationField>Enabled</LocationField>
    <EnableLocationBrowseButton>true</EnableLocationBrowseButton>
    <Icon>sw-file-icon.png</Icon>
    <!-- Indicates how many parent folders this item template should appear in -->
    <NumberOfParentCategoriesToRollUp>1</NumberOfParentCategoriesToRollUp>
  </TemplateData>
  <TemplateContent>
    <Project TargetFileName="ContosoWebFormsMvc.csproj"
      File="ContosoWebFormsMvc.csproj"
      ReplaceParameters="true">     
    </Project>
  </TemplateContent>
</VSTemplate>

Este é um arquivo .vstemplate padrão. Você pode encontrar a referência para esse arquivo em bit.ly/18T090m. Durante o processo de compilação do modelo, arquivos do projeto serão mesclados para criar o arquivo .vstemplate final que é usado para o modelo. Há algumas coisas a serem observadas aqui. Você deve atualizar os seguintes elementos em TemplateData:

Nome: Isso é o nome do seu modelo, conforme mostrado na caixa de diálogo Novo projeto.
Descrição: Esta é a descrição do projeto que é mostrado no lado direito da caixa de diálogo Novo projeto quando o modelo é selecionado.
DefaultName: Esse é o nome padrão do novo projeto que está sendo criado. Um número será acrescentado automaticamente a isso com base no conteúdo do diretório.
Ordem de classificação: Isso determina a posição dos modelos em relação aos outros modelos. Isso deve ser um múltiplo de 10. Quanto menor o número, mais alta será a classificação do item no Visual Studio.
NumberOfParentCategoriesToRollup: Isso determina quantos nós pai no qual o modelo será mostrado.

Você também deve verificar os valores para os atributos TargetFileName e File na marca do projeto. Eles devem corresponder ao nome do projeto no disco. Quando o TemplateBuilder processa esse arquivo, o arquivo .vstemplate final mesclará os arquivos de origem listados no projeto. Se precisar de tratamento especial para quaisquer arquivos específicos, você pode listar esses sob o elemento do projeto. Consulte a referência .vstemplate vinculada anteriormente.

Agora que você personalizou os arquivos _preprocess.xml e. vstemplate.xml, é hora de testar o modelo. Verifique se o projeto do VSIX está configurado como o projeto de inicialização no Visual Studio e, em seguida, pressione Ctrl + F5. Isso inicia a instância Experimental do Visual Studio e o modelo de projeto será carregado automaticamente. Abra a caixa de diálogo Novo Projeto. Se você for para o local que foi definido no arquivo _preprocess.xml, você verá seu modelo recém-criado. Vá em frente e crie um novo projeto usando o novo modelo para testá-lo. Verifique se que tudo está funcionando conforme o esperado.

Se tudo está funcionando bem, parabéns por ter acabado de criar seu primeiro modelo de projeto. Se você quiser instalar esse modelo ou compartilhá-lo com outras pessoas, vá para a pasta bin e localize o arquivo VSIX para instalar. Se você ou sua equipe planeja compartilhar seu projeto por meio de um repositório Git, há uma etapa adicional que você precisa fazer antes de carregá-lo.

Quando você cria um projeto VSIX ou VSPackage, o Visual Studio atualiza o arquivo de projeto com valores para as marcas StartProgram e StartArguments. Esses valores são usados para garantir que F5 e Ctrl+F5 funcionem corretamente. No entanto, essas alterações são configuradas somente em uma base por usuário. Quando você adiciona o projeto para o repositório, o Visual Studio não inclui essas alterações. Elas são salvas em um arquivo .user que se não estiver marcado, então quando outro usuário abrir a solução e tentar executar o projeto em uma instância Experimental, ele pode não funcionar. Para corrigir isso, basta abrir o arquivo .csproj do projeto e adicionar as seguintes linhas antes do final do primeiro grupo de propriedades:

<StartProgram Condition=
    " '$(StartProgram)'=='' ">
    $(DevEnvDir)\devenv.exe
  </StartProgram>
  <StartArguments Condition=
    " '$(StartArguments)'=='' ">
    /rootsuffix Exp</StartArguments>

Agora execute o projeto novamente apenas para garantir que nada ficou meio bagunçado. Se ele funcionar conforme o esperado, você está pronto para adicionar o projeto ao seu repositório Git e compartilhá-lo com todos.

Você acabou de criar uma extensão do Visual Studio que contém um único projeto modelo. Você pode repetir esse processo para incluir outros modelos em sua extensão. Não há nenhum limite para o número de modelos em uma extensão. Você pode compartilhar o modelo em funcionamento com outras pessoas para que elas possam testá-lo. Para fazer isso, você precisa distribuir o arquivo .vsix que está na pasta bin.

Para tornar uma extensão amplamente disponível, você pode carregá-la na Galeria do Visual Studio em bit.ly/115mBzm. Se sua extensão contiver mais de um modelo (um projeto ou um item de modelo), a Galeria não aceitará essas extensões hoje. Em vez de carregá-las diretamente, você pode carregar essas extensões como um link na Galeria do Visual Studio. Se você fizer isso, será necessário hospedar o arquivo .vsix em uma URL disponível publicamente. Você pode usar vsixgallery.com para hospedar o arquivo .vsix e pode usá-lo para compilações noturnas do host. Você pode facilmente automatizar a publicação de compilações noturnas a vsixgallery.com usando o Windows PowerShell ou C#.

Abordamos apenas as noções básicas de criação de modelos de projeto. Há outros cenários, como modelos de vários projetos usando assistentes personalizados e muito mais. Você pode examinar o wiki SideWaffle no GitHub para obter mais informações. Agora é hora de passar para modelos de item.

Adicionando Modelos de Item

Além de permitir que você crie seus próprios modelos de projeto, SideWaffle fornece a capacidade de criar seus próprios modelos de item. Vamos adicionar ao projeto de extensão que acabamos de criar.

Observamos antes que o projeto usou o Bootstrap 3, o jQuery e o Modernizr. Quando o projeto básico tiver sido criado, a qualquer momento que desejarmos criar uma nova página para o site, precisamos criar um novo arquivo HTML e incluir todos os arquivos CSS e Java Script manualmente. Seria bom criar um modelo de item personalizado que faça tudo isso para nós.

Felizmente, TemplateBuilder processa modelos de projeto e de item da mesma forma para manter as coisas consistente para trabalhar com ambos, portanto, algumas das etapas para criar um modelo de item são idênticas as que já fizemos para o modelo de projeto. Durante a compilação do modelo, modelos de item e de projeto essencialmente são processados da mesma maneira. Se você estiver começando a usar um novo projeto, certifique-se de adicionar o pacote TemplateBuilder NuGet primeiro.

Em seguida, crie uma pasta chamada ItemTemplates dentro do projeto do VSIX. Conforme mostrado na Figura 3, essa é a pasta onde todos os modelos de item serão armazenados.

Figura 3 Seu o modelo será exibido na pasta Web

Diretamente sob a pasta ItemTemplates você vai criar diretórios para o item de arquivos de modelo. O nome do primeiro filho do ItemTemplates será o nó no qual o modelo será exibido por padrão. Por exemplo, na Figura 3, você pode ver que criamos uma pasta Web, dessa forma os modelos nessa pasta serão exibidos em Visual C#\Web ou Visual Basic\Web para VB ou da mesma forma para outros idiomas. Você também pode usar _preprocess.xml para alterar isso, mas para este exemplo, vamos colocar todos os modelos de item sob a pasta Web.

Agora vamos criar nosso primeiro modelo de item. Para cada item do modelo, criaremos uma pasta exclusiva em Web e adicionaremos nosso primeiro modelo de item, um modelo básico de inicialização. Para começar, crie uma nova pasta em Web chamada modelo básico de Bootstrap 3. Este modelo conterá dois arquivos HTML (HTMLPage1.html e HTMLPage2.html), então os colocaremos em uma pasta chamada View. Para este exemplo, você pode usar o conteúdo na Figura 4, que foi obtido a partir dos documentos do Bootstrap 3 em bit.ly/1iKHGX3, para ambos os arquivos.

Figura 4 Um modelo de inicialização básico em HTML5

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Basic Bootstrap Template</title>
  <link href="css/bootstrap.min.css" rel="stylesheet">
  <!-- HTML5 shim and Respond.js for IE8 support of -->
  <!-- HTML5 elements and media queries -->
  <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
  <!--[if lt IE9]>
  <script src=
    "https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
  <script src=
    "https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script>
  <![endif]-->
</head>
<body>
  <h1>Hello, world!</h1>
  <script src=
    "https://ajax.googleapis.com/ajax/libs/jquery/1.11.2/jquery.min.js">
    </script>
  <script src="js/bootstrap.min.js"></script>
</body>
</html>

Depois de adicionar os arquivos de origem para a criação do modelo, vamos adicionar os arquivos que incluem os metadados sobre o modelo de item. Para fazer isso, clique com botão direito na pasta do modelo básico de Bootstrap 3 e selecione Adicionar Novo item. Conforme mostrado na Figura 5, selecione o modelo de Item SideWaffle sob o nó Extensibilidade.

Figura 5 O modelo de Item do SideWaffle está localizado no nó Extensibilidade da caixa de diálogo Adicionar Novo Item

O valor na caixa de texto Nome é ignorado aqui porque os arquivos têm nomes de arquivo codificado. Quando você usa o modelo de modelo de Item do SideWaffle, você obtém quatro arquivos em uma nova pasta chamada Definitions (consulte Figura 6). Esses quatro arquivos são CSharp.vstemplat-, VB.vstemplat-, Web.csharp.vstemplat- e Web.VB.vstemplat, correspondente aos principais idiomas/projetos com suporte. CSharp.vstemplate é usada para modelos que aparecerão sob o nó Visual C# para projetos em C#. O VB.vstemplate é usado para modelos que serão exibidos em Visual Basic na caixa de diálogo Novo Item. Os dois arquivos Web são para mostrar o modelo para projetos Web. Observe que, para exibir o modelo, você precisa alterar a extensão de CSharp.vstemplat- para CSharp.vstemplate. Você pode excluir os arquivos nos quais você não está interessado. Conforme mostrado na Figura 6, vamos manter todos os quatro e alterar a extensão para .vstemplate.

Figura 6 O Modelo de item do SideWaffle adiciona uma pasta Definitions e quatro arquivos vstemplate

Agora precisamos editar os arquivos .vstemplate para incluir os dois arquivos de código-fonte HTML no modelo, portanto, adicionaremos alguns elementos do ProjectItem para o arquivo CSharp.vstemplate sob o elemento TemplateContent. O conteúdo do arquivo deve se parecer com o que está mostrado na Figura 7.

Figura 7 Um exemplo do arquivo _project.vstemplate.xml com vários arquivos adicionados ao modelo de Item

<VSTemplate Version="3.0.0"
  xmlns="https://schemas.microsoft.com/developer/vstemplate/2005" Type="Item">
  <TemplateData>
    <ProjectType>CSharp</ProjectType>
    <DefaultName>Bootstrap 3 Basic Template.txt</DefaultName>
    <Name>Bootstrap 3 Basic Template</Name>
    <Description>A basic HTML5 template using Bootstrap 3</Description>   
    <Icon>icon.png</Icon>
    <NumberOfParentCategoriesToRollUp>1</NumberOfParentCategoriesToRollUp>
  </TemplateData>
  <TemplateContent>
    <References />
    <ProjectItem TargetFileName="View/HTMLPage1.html" >
      View/HTMLPage1.html</ProjectItem>
    <ProjectItem TargetFileName="View/HTMLPage2.html" >
      View/HTMLPage2.html</ProjectItem>
  </TemplateContent>
</VSTemplate>

Como você pode ver, adicionamos duas entrada de Projeto e Item correspondentes para os dois arquivos que foram criados. O valor do elemento aponta para o arquivo no disco onde está o conteúdo do modelo. O valor de TargetFileName determinará os nomes dos arquivos que aparecem quando a caixa de diálogo Novo Item é invocada.

Depois de ter adicionado o modelo de item e incluído seus arquivos, você pode testar o modelo de item. Como na última vez, pressione Ctrl+F5 para abrir a instância Experimental do Visual Studio, e crie ou abra um projeto de exemplo e teste o modelo.

Em seguida, vamos discutir os trechos de código, mas primeiro uma rápida observação sobre substituições. Na seção de Modelo de projeto, você viu como _preprocess.xml pode ser usado para atualizar o conteúdo do projeto durante o processo de compilação do modelo. Se você precisar executar qualquer substituição para modelos de item, você pode usar a mesma técnica. Assim como com os modelos de projeto, abordamos apenas as noções básicas de criação de modelos de item. Há muito aonde ainda não chegamos — uso de assistentes personalizados, inserção de ícones como recursos, aninhamento de arquivos e muito mais. Para obter informações sobre esses tópicos, consulte o conteúdo existente para modelos do Visual Studio standard. Você também pode examinar o wiki na página do projeto do SideWaffle do GitHub.

Como adicionar trechos de código

Todos nós temos trechos de código que usamos regularmente em nossos projetos. Se você está se perguntando se não existe uma maneira de fazer o Visual Studio controlar seus trechos de código favoritos, você está com sorte. Assim como antes, comece criando um projeto VSIX e atualizando os campos autor e descrição do source.extension.vsixmanifest.

Para que o Visual Studio leia os arquivos de trechos de código, você precisa criar uma estrutura de pastas que ele reconhece. A Figura 8mostra a estrutura para criar trechos de código para cada linguagem de programação.

Figura 8 As pastas mostradas aqui são reconhecidas automaticamente pelo Visual Studio

Depois de criar as pastas que você precisa, adicione os arquivos de trechos de código para a pasta SideWaffle para o respectivo idioma do trechos de código. Conforme você adiciona cada arquivo, clique no arquivo e examine sua Ação de compilação na janela Propriedades. Cada arquivo deve ter sua propriedade Build Action definida para Conteúdo de forma que o Visual Studio incluirá automaticamente no arquivo do projeto VSIX quando ele for criado.

Em seguida, você precisa adicionar um arquivo de definição de pacote no diretório raiz do seu projeto. O arquivo .pkgdef definirá algumas chaves do registro, permitindo que você use os trechos de código adicionados na última etapa. Porque o Visual Studio não vem com um modelo de Item para arquivos .pkgdef, você precisará criar um arquivo de texto e renomeá-lo para usar a extensão .pkgdef. Você pode nomear o arquivo .pkgdef que você quiser, mas para simplificar as coisas nomeamos o nosso snippets.pkgdef. Conforme mostrado na Figura 9, uma chave do registro diferente precisa ser atualizada para cada idioma que você usa.

Figura 9 Um arquivo de definição de pacote que contém informações de registro para cada idioma

// ---------------------- SNIPPETS ----------------------
// Visual Basic
[$RootKey$\Languages\CodeExpansions\Basic\Paths]
"My Snippets"="$PackageFolder$\Snippets\VisualBasic\My Snippets"
// C++
[$RootKey$\Languages\CodeExpansions\C/C++\Paths]
"My Snippets"="$PackageFolder$\Snippets\C++\My Snippets"
// C#
[$RootKey$\Languages\CodeExpansions\CSharp\Paths]
"My Snippets"="$PackageFolder$\Snippets\CSharp\My Snippets"
// CSS
[$RootKey$\Languages\CodeExpansions\CSS\Paths]
"My Snippets"="$PackageFolder$\Snippets\CSS\My Snippets"
// HTML
[$RootKey$\Languages\CodeExpansions\HTML\Paths]
"My Snippets"=""$PackageFolder$\Snippets\HTML\My Snippets"
// JavaScript
[$RootKey$\Languages\CodeExpansions\JavaScript\Paths]
"My Snippets"="$PackageFolder$\Snippets\JavaScript\My Snippets"
// SQL
[$RootKey$\Languages\CodeExpansions\SQL_SSDT\Paths]
"My Snippets"="$PackageFolder$\Snippets\SQL\My Snippets"
// XML
[$RootKey$\Languages\CodeExpansions\XML\Paths]
"My Snippets"="$PackageFolder$\Snippets\XML\My Snippets"

A última etapa antes de testar seus novos trechos de código é registrar o arquivo pkgdef. Abra o arquivo source.extension.vsixmanifest, alterne para a guia Assets e clique no botão rotulado como Novo. A caixa de diálogo Adicionar Novo ativo deve aparecer, dando a você várias opções. Conforme mostrado na Figura 10, selecione Microsoft.VisualStudio.VsPackage para o tipo de ativo.

Figura 10 Registro do arquivo de definição de pacote com o Visual Studio

Em seguida, selecione o arquivo no sistema de arquivos como o tipo de origem. Isso fará com que a expansão da caixa de diálogo, oferecendo a capacidade de navegar até o arquivo .pkgdef criado. Selecione o arquivo .pkgdef e clique em OK.

Agora, você está pronto para testar seus trechos de código. Como antes, pressione Ctrl+F5 para abrir uma instância experimental do Visual Studio. Em seguida, abra o projeto anteriormente usado para teste e navegue até Ferramentas | Gerenciador de trechos de código. Se tudo for carregado corretamente, você terá concluído.

Agora examinamos os principais benefícios de SideWaffle até agora: modelos de projeto e item e trechos de código. O que vem a seguir?

A equipe de desenvolvimento está atualmente trabalhando em um recurso de modelos dinâmicos para SideWaffle, que esperamos estar prontas para a próxima versão. Isso tornará muito mais simples criar e manter modelos. A ideia é que você possa publicar seus modelos em um repositório Git ou uma pasta de rede e compartilhá-los com amigos e colegas. Em seguida, você pode configurar o SideWaffle para pegar modelos a partir do local remoto. O usuário final poderá controlar a frequência de verificação para atualizações. Para se manter atualizado com esse recurso, visite a página de Modelo dinâmico em bit.ly/18DepKM.

Conclusão

Como você viu neste artigo, a criação de seus próprios modelos é bastante simples. Agora que você sabe como fazer isso, você pode mostrar a seus amigos e colegas quanto tempo você está salvando com o SideWaffle. Lembre-se, ao compartilhar seu pacote de modelo com a comunidade, você pode sempre carregá-los para a Galeria do Visual Studio, e vsixgallery.com sempre estará disponível se você precisar dela. Se você quiser compartilhar seus próprios modelos com outras pessoas por meio do SideWaffle, envie uma solicitação pull no GitHub. Agora, comece a criar seu pacote de modelo e fale conosco se precisar de qualquer ajuda.

Tyler Hughes formou-se recentemente pela Universidade do Estado em Jacksonville onde estudou Sistemas de informações em Computação. Ele foi desenvolvedor entusiasta por cinco anos e atualmente é parte da equipe de desenvolvedores principal do SideWaffle.

Sayed Ibrahim Hashimi é gerente sênior de programas da Microsoft na equipe do Visual Studio Web. Ele escreveu vários livros sobre tecnologias da Microsoft e é o criador do SideWaffle e TemplateBuilder, bem como cocriador do OmniSharp.