Criar um sistema de projeto básico, parte 2

Artigo
10/10/2023

O primeiro passo a passo desta série, Criar um sistema de projeto básico, parte 1, mostra como criar um sistema de projeto básico. Este passo a passo baseia-se no sistema de projeto básico adicionando um modelo do Visual Studio, uma página de propriedades e outros recursos. Você deve concluir o primeiro passo a passo antes de iniciar este.

Este passo a passo ensina como criar um tipo de projeto que tenha a extensão de nome de arquivo de projeto .myproj. Para concluir o passo a passo, você não precisa criar sua própria linguagem porque o passo a passo toma emprestado do sistema de projeto Visual C# existente.

Este passo a passo ensina como realizar estas tarefas:

Crie um modelo do Visual Studio.
Implante um modelo do Visual Studio.
Crie um nó filho de tipo de projeto na caixa de diálogo Novo Projeto .
Habilite a substituição de parâmetros no modelo do Visual Studio.
Crie uma página de propriedades do projeto.

Observação

As etapas neste passo a passo são baseadas em um projeto C#. No entanto, exceto para especificidades, como extensões de nome de arquivo e código, você pode usar as mesmas etapas para um projeto do Visual Basic.

Criar um modelo do Visual Studio

Criar um sistema de projeto básico, a parte 1 mostra como criar um modelo de projeto básico e adicioná-lo ao sistema de projeto. Ele também mostra como registrar esse modelo com o Visual Studio usando o atributo ProvideProjectFactoryAttribute , que grava o caminho completo da pasta \Templates\Projects\SimpleProject\ no registro do sistema.

Usando um modelo do Visual Studio (arquivo .vstemplate) em vez de um modelo de projeto básico, você pode controlar como o modelo aparece na caixa de diálogo Novo projeto e como os parâmetros do modelo são substituídos. Um arquivo .vstemplate é um arquivo XML que descreve como os arquivos de origem devem ser incluídos quando um projeto é criado usando o modelo de sistema de projeto. O próprio sistema de projeto é criado coletando o arquivo .vstemplate e os arquivos de origem em um arquivo .zip e implantado copiando o arquivo .zip para um local conhecido pelo Visual Studio. Esse processo é explicado com mais detalhes mais adiante neste passo a passo.

No Visual Studio, abra a solução SimpleProject que você criou seguindo Criar um sistema de projeto básico, parte 1.
No arquivo SimpleProjectPackage.cs , localize o atributo ProvideProjectFactory. Substitua o segundo parâmetro (o nome do projeto) por null e o quarto parâmetro (o caminho para a pasta de modelo do projeto) por ".\\NullPath", da seguinte maneira.
```
[ProvideProjectFactory(typeof(SimpleProjectFactory), null,
    "Simple Project Files (*.myproj);*.myproj", "myproj", "myproj",
    ".\\NullPath",
LanguageVsTemplate = "SimpleProject")]
```
Adicione um arquivo XML chamado SimpleProject.vstemplate à pasta \Templates\Projects\SimpleProject\ .

Substitua o conteúdo de SimpleProject.vstemplate com o código a seguir.

<VSTemplate Version="2.0.0" Type="Project"
    xmlns="http://schemas.microsoft.com/developer/vstemplate/2005">
  <TemplateData>
    <Name>SimpleProject Application</Name>
    <Description>
      A project for creating a SimpleProject application
    </Description>
    <Icon>SimpleProject.ico</Icon>
    <ProjectType>SimpleProject</ProjectType>
  </TemplateData>
  <TemplateContent>
    <Project File="SimpleProject.myproj" ReplaceParameters="true">
      <ProjectItem ReplaceParameters="true" OpenInEditor="true">
        Program.cs
      </ProjectItem>
      <ProjectItem ReplaceParameters="true" OpenInEditor="false">
        AssemblyInfo.cs
      </ProjectItem>
    </Project>
  </TemplateContent>
</VSTemplate>

Na janela Propriedades, selecione todos os cinco arquivos na pasta \Templates\Projects\SimpleProject\ e defina a Ação de Criação como ZipProject.

A <seção TemplateData> determina o local e a aparência do tipo de projeto SimpleProject na caixa de diálogo Novo Projeto , da seguinte maneira:

O <elemento Name> nomeia o modelo de projeto para ser SimpleProject Application.
O <elemento Description> contém a descrição que aparece na caixa de diálogo Novo Projeto quando o modelo de projeto é selecionado.
O <elemento Icon> especifica o ícone que aparece junto com o tipo de projeto SimpleProject.
O <elemento ProjectType> nomeia o tipo Project na caixa de diálogo Novo Projeto . Esse nome substitui o parâmetro de nome do projeto do atributo ProvideProjectFactory.

Observação

O <elemento ProjectType> deve corresponder ao LanguageVsTemplateProvideProjectFactory argumento do atributo no arquivo SimpleProjectPackage.cs .

A <seção TemplateContent> descreve esses arquivos que são gerados quando um novo projeto é criado:
SimpleProject.myproj
Module.vb
AssemblyInfo.cs

Todos os três arquivos foram ReplaceParameters definidos como true, o que permite a substituição de parâmetros. O arquivo Program.cs foi OpenInEditor definido como true, o que faz com que o arquivo seja aberto no editor de código quando um projeto é criado.

Para obter mais informações sobre os elementos no esquema de modelo do Visual Studio, consulte a referência de esquema de modelo do Visual Studio.

Observação

Se um projeto tiver mais de um modelo do Visual Studio, cada modelo estará em uma pasta separada. Cada arquivo nessa pasta deve ter a ação de compilação definida como ZipProject.

Adicionando um arquivo .vsct mínimo

Visual Studio deve ser executado no modo de instalação para reconhecer um modelo novo ou modificado do Visual Studio. O modo de instalação requer a presença de um arquivo .vsct . Portanto, você deve adicionar um arquivo .vsct mínimo ao projeto.

Adicione um arquivo XML chamado SimpleProject.vsct ao projeto SimpleProject.

Substitua o conteúdo do arquivo SimpleProject.vsct com o código a seguir.

<?xml version="1.0" encoding="utf-8" ?>
<CommandTable
  xmlns="http://schemas.microsoft.com/VisualStudio/2005-10-18/CommandTable">
</CommandTable>

Defina a ação de compilação deste arquivo como VSCTCompile. Você pode fazer isso somente no arquivo .csproj , não na janela Propriedades . Certifique-se de que a ação de compilação deste arquivo está definida como Nenhum neste momento.
1. Clique com o botão direito do mouse no nó SimpleProject e clique em Editar SimpleProject.csproj.
2. No arquivo .csproj, localize o item SimpleProject.vsct.
```
<None Include="SimpleProject.vsct" />
```
3. Altere a ação de compilação para VSCTCompile.
```
<VSCTCompile Include="SimpleProject.vsct" />
```
4. o arquivo de projeto e feche o editor.
5. Salve o nó SimpleProject e, no Gerenciador de Soluções , clique em Recarregar Projeto.

Examine as etapas de compilação do modelo do Visual Studio

O sistema de compilação de projeto VSPackage normalmente executa o Visual Studio no modo de instalação quando o arquivo .vstemplate é alterado ou o projeto que contém o arquivo .vstemplate é recriado. Você pode acompanhar definindo o nível de detalhamento do MSBuild como Normal ou superior.

No menu Ferramentas, clique em Opções.
Expanda o nó Projetos e Soluções e selecione Compilar e Executar.
Defina o detalhamento de saída da compilação do projeto MSBuild como Normal. Clique em OK.
Reconstrua o projeto SimpleProject.

A etapa de compilação para criar o arquivo de projeto .zip deve ser semelhante ao exemplo a seguir.

ZipProjects:
1>  Zipping ProjectTemplates
1>  Zipping <path>\SimpleProject\SimpleProject\obj\Debug\SimpleProject.zip...
1>  Copying file from "<path>\SimpleProject\SimpleProject\obj\Debug\SimpleProject.zip" to "<%LOCALAPPDATA%>\Microsoft\VisualStudio\14.0Exp\ProjectTemplates\\\\SimpleProject.zip".
1>  Copying file from "<path>\SimpleProject\SimpleProject\obj\Debug\SimpleProject.zip" to "bin\Debug\\ProjectTemplates\\\\SimpleProject.zip".
1>  SimpleProject -> <path>\SimpleProject\SimpleProject\bin\Debug\ProjectTemplates\SimpleProject.zip
1>ZipItems:
1>  Zipping ItemTemplates
1>  SimpleProject ->

Implantar um modelo do Visual Studio

Os modelos do Visual Studio não contêm informações de caminho. Portanto, o arquivo de .zip de modelo deve ser implantado em um local conhecido pelo Visual Studio. O local da pasta ProjectTemplates normalmente <é %LOCALAPPDATA%>\Microsoft\VisualStudio\14.0Exp\ProjectTemplates.

Para implantar sua fábrica de projetos, o programa de instalação deve ter privilégios de administrador. Ele implanta modelos no nó de instalação do Visual Studio: ...\Microsoft Visual Studio 14.0\Common7\IDE\ProjectTemplates.

Testar um modelo do Visual Studio

Teste sua fábrica de projeto para ver se ela cria uma hierarquia de projeto usando o modelo do Visual Studio.

Redefina a instância experimental do SDK do Visual Studio.

No Windows 7: no menu Iniciar, localize a pasta SDK/Ferramentas do Microsoft Visual Studio/Microsoft Visual Studio e selecione Redefinir a instância experimental do Microsoft Visual Studio.

Em versões posteriores do Windows: Na tela Iniciar, digite Redefinir a Instância Experimental da versão> do Microsoft Visual Studio<.
Uma janela de prompt de comando é exibida. Quando vir as palavras Prima qualquer tecla para continuar, clique em ENTER. Depois que a janela for fechada, abra o Visual Studio.
Recrie o projeto SimpleProject e inicie a depuração. A instância experimental é exibida.
Na instância experimental, crie um projeto SimpleProject. Na caixa de diálogo Novo Projeto, selecione SimpleProject.
Você deve ver uma nova instância de SimpleProject.

Criar um nó filho do tipo de projeto

Você pode adicionar um nó filho a um nó de tipo de projeto na caixa de diálogo Novo Projeto . Por exemplo, para o tipo de projeto SimpleProject, você pode ter nós filho para aplicativos de console, aplicativos de janela, aplicativos Web e assim por diante.

Os nós filho são criados alterando o arquivo de projeto e adicionando <filhos OutputSubPath> aos <elementos ZipProject> . Quando um modelo é copiado durante a compilação ou implantação, cada nó filho se torna uma subpasta da pasta de modelos de projeto.

Esta seção mostra como criar um nó filho do Console para o tipo de projeto SimpleProject.

Renomeie a pasta \Templates\Projects\SimpleProject\ para \Templates\Projects\ConsoleApp\.
Na janela Propriedades, selecione todos os cinco arquivos na pasta \Templates\Projects\ConsoleApp\ e verifique se a Ação de Criação está definida como ZipProject.
No arquivo SimpleProject.vstemplate, adicione a seguinte linha no final da seção TemplateData>, logo antes da <marca de fechamento.
```
<NumberOfParentCategoriesToRollUp>1</NumberOfParentCategoriesToRollUp>
```
Isso faz com que o modelo Aplicativo de Console apareça no nó filho Console e no nó pai SimpleProject, que é um nível acima do nó filho.
Salve o arquivo SimpleProject.vstemplate .
No arquivo .csproj, adicione <OutputSubPath> a cada um dos elementos ZipProject. Descarregue o projeto, como antes, e edite o arquivo de projeto.

Localize os <elementos ZipProject> . Para cada <elemento ZipProject> , adicione um <elemento OutputSubPath> e dê a ele o valor Console. O ZipProject

<ZipProject Include="Templates\Projects\ConsoleApp\AssemblyInfo.cs">
  <OutputSubPath>Console</OutputSubPath>
</ZipProject>
<ZipProject Include="Templates\Projects\ConsoleApp\Program.cs">
  <OutputSubPath>Console</OutputSubPath>
</ZipProject>
<ZipProject Include="Templates\Projects\ConsoleApp\SimpleProject.myproj">
  <OutputSubPath>Console</OutputSubPath>
</ZipProject>
<ZipProject Include="Templates\Projects\ConsoleApp\SimpleProject.vstemplate">
  <OutputSubPath>Console</OutputSubPath>
</ZipProject>
<ZipProject Include="Templates\Projects\ConsoleApp\SimpleProject.ico">
  <OutputSubPath>Console</OutputSubPath>
</ZipProject>

Adicione este <PropertyGroup> ao arquivo de projeto:

<PropertyGroup>
  <VsTemplateLanguage>SimpleProject</VsTemplateLanguage>
</PropertyGroup>

Salve o arquivo de projeto e recarregue o projeto.

Testar o nó filho do tipo de projeto

Teste o arquivo de projeto modificado para ver se o nó filho do Console aparece na caixa de diálogo Novo Projeto.

Execute a ferramenta Redefinir a instância experimental do Microsoft Visual Studio.
Recrie o projeto SimpleProject e inicie a depuração. A instância experimental deve aparecer
Na caixa de diálogo Novo Projeto, clique no nó SimpleProject. O modelo Aplicativo de Console deve aparecer no painel Modelos .
Expanda o nó SimpleProject . O nó filho do console deve aparecer. O modelo Aplicativo SimpleProject continua a aparecer no painel Modelos .
Clique em Cancelar e pare a depuração.

Substituir parâmetros de modelo de projeto

Criando um sistema de projeto básico, a parte 1 mostrou como substituir o ProjectNode.AddFileFromTemplate método para fazer um tipo básico de substituição de parâmetro de modelo. Esta seção ensina como usar os parâmetros de modelo mais sofisticados do Visual Studio.

Quando você cria um projeto usando um modelo do Visual Studio na caixa de diálogo Novo projeto, os parâmetros de modelo são substituídos por cadeias de caracteres para personalizar o projeto . Um parâmetro de modelo é um token especial que começa e termina com um cifrão, por exemplo, $time$. Os dois parâmetros a seguir são especialmente úteis para habilitar a personalização em projetos baseados no modelo:

$GUID[1-10]$ é substituído por um novo Guid. Você pode especificar até 10 GUIDs exclusivos, por exemplo, $guid 1$.
$safeprojectname$ é o nome fornecido por um usuário na caixa de diálogo Novo Projeto , modificado para remover todos os caracteres e espaços não seguros.

Para obter uma lista completa dos parâmetros de modelo, consulte Parâmetros de modelo.

Para substituir parâmetros de modelo de projeto

No arquivo SimpleProjectNode.cs , remova o AddFileFromTemplate método.
No arquivo \Templates\Projects\ConsoleApp\SimpleProject.myproj, localize a <propriedade RootNamespace> e altere seu valor para $safeprojectname$.
```
<RootNamespace>$safeprojectname$</RootNamespace>
```

No arquivo \Templates\Projects\SimpleProject\Program.cs substitua o conteúdo do arquivo com o seguinte código:

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;    // Guid

namespace $safeprojectname$
{
    [Guid("$guid1$")]
    public class $safeprojectname$
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello VSX!!!");
            Console.ReadKey();
        }
    }
}

Recrie o projeto SimpleProject e inicie a depuração. A instância experimental deve aparecer.
Crie um novo aplicativo SimpleProject Console. (No Painel Tipos de projeto, selecione SimpleProject. Em Modelos instalados do Visual Studio, selecione Aplicativo de Console.)

No projeto recém-criado, abra Programa.cs. Ele deve se parecer com o seguinte (os valores de GUID em seu arquivo serão diferentes.):

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;    // Guid

namespace Console_Application1
{
    [Guid("00000000-0000-0000-00000000-00000000)"]
    public class Console_Application1
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello VSX!!!");
            Console.ReadKey();
        }
    }
}

Criar uma página de propriedades do projeto

Você pode criar uma página de propriedades para seu tipo de projeto para que os usuários possam exibir e alterar propriedades em projetos baseados em seu modelo. Esta seção mostra como criar uma página de propriedades independente de configuração. Esta página de propriedades básicas usa uma grade de propriedades para exibir as propriedades públicas que você expõe em sua classe de página de propriedades.

Derive sua classe de página de propriedade da SettingsPage classe base. A grade de propriedades fornecida pela SettingsPage classe está ciente da maioria dos tipos de dados primitivos e sabe como exibi-los. Além disso, a SettingsPage classe sabe como persistir valores de propriedade para o arquivo de projeto.

A página de propriedades criada nesta seção permite alterar e salvar estas propriedades do projeto:

AssemblyName
OutputType
RootNamespace.

No arquivo SimpleProjectPackage.cs adicione este ProvideObject atributo à SimpleProjectPackage classe:
```
[ProvideObject(typeof(GeneralPropertyPage))]
public sealed class SimpleProjectPackage : ProjectPackage
```
Isso registra a classe GeneralPropertyPage de página de propriedades com COM.

No arquivo SimpleProjectNode.cs adicione esses dois métodos substituídos à SimpleProjectNode classe:

protected override Guid[] GetConfigurationIndependentPropertyPages()
{
    Guid[] result = new Guid[1];
    result[0] = typeof(GeneralPropertyPage).GUID;
    return result;
}
protected override Guid[] GetPriorityProjectDesignerPages()
{
    Guid[] result = new Guid[1];
    result[0] = typeof(GeneralPropertyPage).GUID;
    return result;
}

Ambos os métodos retornam uma matriz de GUIDs de página de propriedades. O GUID GeneralPropertyPage é o único elemento na matriz, portanto, a caixa de diálogo Páginas de propriedades mostrará apenas uma página.

Adicione um arquivo de classe chamado GeneralPropertyPage.cs ao projeto SimpleProject.

Substitua o conteúdo desse arquivo usando o seguinte código:

using System;
using System.Runtime.InteropServices;
using Microsoft.VisualStudio;
using Microsoft.VisualStudio.Project;
using System.ComponentModel;

namespace SimpleProject
{
    [ComVisible(true)]
    [Guid("6BC7046B-B110-40d8-9F23-34263D8D2936")]
    public class GeneralPropertyPage : SettingsPage
    {
        private string assemblyName;
        private OutputType outputType;
        private string defaultNamespace;

        public GeneralPropertyPage()
        {
            this.Name = "General";
        }

        [Category("AssemblyName")]
        [DisplayName("AssemblyName")]
        [Description("The output file holding assembly metadata.")]
        public string AssemblyName
        {
            get { return this.assemblyName; }
        }
        [Category("Application")]
        [DisplayName("OutputType")]
        [Description("The type of application to build.")]
        public OutputType OutputType
        {
            get { return this.outputType; }
            set { this.outputType = value; this.IsDirty = true; }
        }
        [Category("Application")]
        [DisplayName("DefaultNamespace")]
        [Description("Specifies the default namespace for added items.")]
        public string DefaultNamespace
        {
            get { return this.defaultNamespace; }
            set { this.defaultNamespace = value; this.IsDirty = true; }
        }

        protected override void BindProperties()
        {
            this.assemblyName = this.ProjectMgr.GetProjectProperty("AssemblyName", true);
            this.defaultNamespace = this.ProjectMgr.GetProjectProperty("RootNamespace", false);

            string outputType = this.ProjectMgr.GetProjectProperty("OutputType", false);
            this.outputType = (OutputType)Enum.Parse(typeof(OutputType), outputType);
        }

        protected override int ApplyChanges()
        {
            this.ProjectMgr.SetProjectProperty("AssemblyName", this.assemblyName);
            this.ProjectMgr.SetProjectProperty("OutputType", this.outputType.ToString());
            this.ProjectMgr.SetProjectProperty("RootNamespace", this.defaultNamespace);
            this.IsDirty = false;

            return VSConstants.S_OK;
        }
    }
}

A GeneralPropertyPage classe expõe as três propriedades públicas AssemblyName, OutputType e RootNamespace. Como AssemblyName não tem nenhum método set, ele é exibido como uma propriedade somente leitura. OutputType é uma constante enumerada, portanto, aparece como lista suspensa.

A SettingsPage classe base fornece ProjectMgr para persistir as propriedades. O BindProperties método usa ProjectMgr para recuperar os valores de propriedade persistente e definir as propriedades correspondentes. O ApplyChanges método usa ProjectMgr para obter os valores das propriedades e persisti-los para o arquivo de projeto. O método do conjunto de propriedades define IsDirty como true para indicar que as propriedades precisam ser persistentes. A persistência ocorre quando você salva o projeto ou a solução.

Recrie a solução SimpleProject e inicie a depuração. A instância experimental deve aparecer.
Na instância experimental, crie um novo aplicativo SimpleProject.
O Visual Studio chama sua fábrica de projeto para criar um projeto usando o modelo do Visual Studio. O novo arquivo Program.cs é aberto no editor de códigos.
Clique com o botão direito do mouse no nó do projeto no Gerenciador de Soluções e clique em Propriedades. A caixa de diálogo Páginas da Propriedade é exibida.

Testar a página de propriedades do projeto

Agora você pode testar se pode modificar e alterar valores de propriedade.

Na caixa de diálogo MyConsoleApplication Property Pages , altere o DefaultNamespace para MyApplication.
Selecione a propriedade OutputType e, em seguida, selecione Biblioteca de classes.
Clique em Aplicar e em OK.
Reabra a caixa de diálogo Páginas de Propriedades e verifique se as alterações foram persistentes.
Feche a Instância Experimental do Visual Studio.
Reabra a instância experimental.
Reabra a caixa de diálogo Páginas de Propriedades e verifique se as alterações foram persistentes.
Feche a Instância Experimental do Visual Studio.

Compartilhar via