Criar um sistema de projeto básico, parte 2

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 se baseia 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 mostra como criar um tipo de projeto que tenha a extensão do nome do arquivo do projeto .myproj. Para concluir o passo a passo, você não precisa criar seu próprio idioma porque o passo a passo é emprestado do sistema de projetos do Visual C# existente.

Este passo a passo ensina como realizar essas tarefas:

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

Observação

As etapas neste passo a passo são baseadas em um projeto em C#. No entanto, com exceção de detalhes, 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 projetos. Ele também mostra como registrar esse modelo no Visual Studio usando o ProvideProjectFactoryAttribute atributo, 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 de 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 do 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 posteriormente 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 nulo e o quarto parâmetro (o caminho para a pasta de modelo de 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 pelo 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 Build 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 Aplicativo SimpleProject.
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 TipoDeProjeto> nomeia o tipo de projeto 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 argumento LanguageVsTemplate do atributo ProvideProjectFactory no arquivo SimpleProjectPackage.cs.

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

Todos os três arquivos foram ReplaceParameters definidos como true, o que permite a substituição de parâmetro. 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 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 Build definida como ZipProject.

Adicionando um arquivo .vsct mínimo

O 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 que um arquivo .vsct esteja presente. 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 pelo 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 Build desse arquivo como VSCTCompile. Você pode fazer isso apenas no arquivo .csproj , não na janela Propriedades . Verifique se a Build Action deste arquivo está definida como Nenhuma neste momento.
1. Clique com o botão direito do mouse no nó SimpleProject e selecione Editar SimpleProject.csproj.
2. No arquivo .csproj , localize o item SimpleProject.vsct .
```
<None Include="SimpleProject.vsct" />
```
3. Altere a ação de build para VSCTCompile.
```
<VSCTCompile Include="SimpleProject.vsct" />
```
4. o arquivo de projeto e feche o editor.
5. Salve o nó SimpleProject e, em seguida, no Gerenciador de Soluções , selecione Recarregar Projeto.

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

O sistema de build do 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 verbosidade do MSBuild como Normal ou superior.

No painel Ferramentas>Opções, expanda a seção Todos as Configurações>Projetos e Soluções>Compilação e Execução.
Defina a opção de verbosidade de saída de build do projeto MSBuild como Normal.

Na caixa de diálogo Ferramentas>Opções, expanda a seção Projetos e Soluções>Compilação e Execução.
Defina a opção de verbosidade de saída de build do projeto MSBuild como Normal e selecione OK.

Recompile o projeto SimpleProject.

A etapa de build 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 modelo .zip arquivo 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 a fábrica de projetos 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 Inicial, digite Redefinir a Instância Experimental da versão< do Microsoft Visual Studio>.
Uma janela do prompt de comando é exibida. Quando você vir as palavras Pressionar qualquer tecla para continuar, selecione ENTER. Depois que a janela for fechada, abra o Visual Studio.
Recompile 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 do SimpleProject.

Criar um nó filho para tipo de projeto

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

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 Build está definida como ZipProject.
No arquivo SimpleProject.vstemplate, adicione a seguinte linha ao final da <TemplateData> seção, pouco antes da marca de fechamento.
```
<NumberOfParentCategoriesToRollUp>1</NumberOfParentCategoriesToRollUp>
```
Isso faz com que o template de Aplicativo de Console apareça no nó filho do 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.

Ache os <elementos ZipProject>. Para cada <elemento ZipProject> , adicione um <elemento OutputSubPath> e dê a ele o valor Console. 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 na arquitetura de tipo de projeto

Teste o arquivo de projeto modificado para confirmar 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 .
Recompile o projeto SimpleProject e inicie a depuração. A instância experimental deverá aparecer
Na caixa de diálogo Novo Projeto, selecione o nó SimpleProject. O modelo de 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 .
Selecione Cancelar e interrompa a depuração.

Substituir parâmetros de modelo de projeto

Criando um sistema de projeto básico, a parte 1 mostrou como sobrescrever 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 sinal de dólar, 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 de 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 pelo 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();
        }
    }
}

Recompile o projeto SimpleProject e inicie a depuração. A instância experimental provavelmente 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 Program.cs. Ele deve ser semelhante ao seguinte (os valores GUID em seu arquivo diferem.):

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 propriedade do projeto

Você pode criar uma página de propriedade para o 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 propriedade independente de configuração. Esta página de propriedade básica usa uma grade de propriedades para exibir as propriedades públicas que você expõe em sua classe de página de propriedade.

Derive sua classe de página de propriedade da classe base SettingsPage. 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 manter valores de propriedade no arquivo de projeto.

A página de propriedades criada nesta seção permite alterar e salvar essas 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 estes 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 da página de propriedades. O GUID GeneralPropertyPage é o único elemento na matriz, portanto, a caixa de diálogo Páginas de Propriedades mostra apenas uma página.

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

Substitua o conteúdo deste 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 um método definido, ele é exibido como uma propriedade somente leitura. OutputType é uma constante enumerada, portanto, ela 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 persistentes e definir as propriedades correspondentes. O ApplyChanges método usa ProjectMgr para obter os valores das propriedades e persistê-los no arquivo de projeto. O método de conjunto de propriedades é definido IsDirty como true para indicar que as propriedades devem ser mantidas. A persistência ocorre quando você salva o projeto ou a solução.

Recompile 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 projetos para criar um projeto usando o modelo do Visual Studio. O novo arquivo Program.cs é aberto no editor de código.
Clique com o botão direito do mouse no nó do projeto no Gerenciador de Soluções e selecione Propriedades. A caixa de diálogo Páginas de Propriedades é exibida.

Testar a página de propriedades do projeto

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

Altere DefaultNamespace para MyApplication na caixa de diálogo Páginas da Propriedade MyConsoleApplication.
Selecione a propriedade OutputType e, em seguida, selecione Biblioteca de Classes.
Selecione Aplicar e selecione OK.
Reabra a caixa de diálogo Páginas de Propriedades e verifique se as alterações foram mantidas.
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 mantidas.
Feche a instância experimental do Visual Studio.

Last updated on 2025-12-12

Compartilhar via