Partilhar via

Como criar configurações de compilação de solução e de projeto

  • Artigo

Os suplementos do Visual Studio foram substituídos no Visual Studio 2013. Você deve atualizar seus suplementos para as extensões VSPackage. Para obter mais informações sobre atualização, consulte Perguntas frequentes: convertendo suplementos em extensões VSPackage.

O modelo de automação do Visual Studio oferece os objetos que permitem controlar as configurações criadas pela solução e pelo projeto. Uma configuração de compilação de solução especifica como determinados projetos em uma solução devem ser compilados e, se habilitado, implantados. As configurações de compilação do projeto, que estão listadas na caixa de diálogo Páginas de Propriedades do Projeto, listam todos os tipos disponíveis de compilações de projeto, como Debug ou Release e as plataformas disponíveis, como .NET ou Win32. Para cada combinação de compilação e plataforma, há uma configuração de projeto, um conjunto de propriedades e configurações definidas do projeto.

Os objetos de configuração de criação de solução são:

Nome do objeto

Descrição

Objeto SolutionBuild2

Usado para criar, limpar e implantar a configuração de solução ativa atual.

Objeto SolutionConfiguration2

Representa uma lista de projetos e suas configurações que devem ser compilados.

Coleção SolutionConfigurations

Contém todos os objetos definidos SolutionConfiguration.

Objeto SolutionContext

Representa a configuração de um projeto em um objeto SolutionConfiguration.

Coleção SolutionContexts

Contém todos os objetos SolutionContext em um objeto SolutionConfiguration.

Objeto BuildDependency

Contém um projeto que deve ser compilado antes do projeto proprietário ser compilado.

Coleção BuildDependencies

Contém todos os projetos que devem ser compilados antes que o projeto proprietário seja compilado.

Os objetos de configuração de criação de projeto são:

Nome do objeto

Descrição

Objeto ConfigurationManager

Representa a configuração e as plataformas de compilação.

Objeto Configuration

Representa uma configuração ou conjunto de configurações de compilação em uma plataforma especificada.

Coleção Configurations

Contém todos os objetos Configuration.

Objeto OutputGroup

Contém os arquivos compilados pelo projeto.

coleção OutputGroups

Contém todos os objetos OutputGroup.

Usando esses objetos, será possível:

  • Criar, adicionar projetos, ativar, e excluir as configurações de solução.

  • Compile, execute ou implante qualquer projeto em uma configuração de solução.

  • Obtenha informações sobre objetos em um projeto ou uma configuração da solução.

  • Adicione, remova ou obtenha informações sobre dependências de compilação do projeto.

Dica

As caixas de diálogo e os comandos de menu que você vê podem diferir das descritas no Help dependendo de suas configurações ativas ou de edição.Esses procedimentos foram desenvolvidos com as Configurações Gerais de Desenvolvimento ativas.Para alterar as configurações, escolha Importar e ExportarConfigurações no menu de Ferramentas.Para obter mais informações, consulte Personalizando configurações de desenvolvimento no Visual Studio.

Exemplo

Public Sub OnConnection(ByVal application As Object, ByVal _
connectMode As ext_ConnectMode, ByVal addInInst As Object, _
ByRef custom As Array) Implements IDTExtensibility2.OnConnection
    _applicationObject = CType(application, DTE2)
    _addInInstance = CType(addInInst, AddIn)
    SConfig(_applicationObject)
End Sub
Sub SConfig(ByVal dte As DTE2)
    Dim SB As SolutionBuild2 =  _
    CType(_applicationObject.Solution.SolutionBuild, _
    SolutionBuild2)
    Dim SolCtx As SolutionContext
    Dim Proj As Project
    Dim CM As ConfigurationManager
    Dim Cfgs As SolutionConfigurations
    Dim Cfg As SolutionConfiguration2
    Dim msg As String

    ' Get a reference to the solution configurations 
    ' solution context of the first project.
    SolCtx = SB.SolutionConfigurations.Item(1).SolutionContexts.Item(1)
   CM = _applicationObject.Solution.Projects. _
    Item(1).ConfigurationManager
    Proj = _applicationObject.Solution.Projects.Item(1)
    Cfgs = _applicationObject.Solution.SolutionBuild. _
    SolutionConfigurations
    Cfg = CType(Cfgs.Item(1), SolutionConfiguration2)

    ' List the current solution build info.
    msg = "BuildState = "
    Select Case SB.BuildState
        Case vsBuildState.vsBuildStateNotStarted
            msg = msg & "Build has not yet started." & vbCr
        Case vsBuildState.vsBuildStateInProgress
            msg = msg & "Build is in progress." & vbCr
        Case vsBuildState.vsBuildStateDone
            msg = msg & "Build has completed." & vbCr
    End Select
    msg = msg & "Configuration Name = " & SolCtx.ConfigurationName _
    & vbCr
    msg = msg & "Platform Name = " & SolCtx.PlatformName & vbCr
    msg = msg & "Project Name = " & SolCtx.ProjectName & vbCr
    MsgBox(msg)

    ' List the current solution configurations.
    msg = ("Configuration names are:" & vbCr)
    For Each Cfg In Cfgs
        msg = msg & Cfg.Name & vbCr
    Next
    MsgBox(msg)
   ' Add a new solution configuration.
   Cfgs.Add("ANewConfiguration", "Debug", False)
   MsgBox(Cfgs.Item(1).Name)
   ' Create a new project build configuration based on the Debug 
   ' configuration.
   Proj.ConfigurationManager.AddConfigurationRow("MyNewConfig", _
    "Debug", True)
   ' Build the solution configuration.
   sb.SolutionConfigurations.Item("MyConfig").Activate()
   sb.Build()
End Sub

public void OnConnection(object application, 
ext_ConnectMode connectMode, object addInInst, ref Array custom)
{
    _applicationObject = (DTE2)application;
    _addInInstance = (AddIn)addInInst;
    SConfig(_applicationObject);
}
public void SConfig(DTE2 dte)
{
    try
    {
        SolutionBuild2 SB =
 (SolutionBuild2)_applicationObject.Solution.SolutionBuild;
        SolutionContext SolCtx;
        Project Proj;
        ConfigurationManager CM;
        SolutionConfigurations Cfgs;
        SolutionConfiguration2 Cfg;
        String msg;
        // Get a reference to the solution configurations
        // solution context of the first project.
        SolCtx = SB.SolutionConfigurations.Item(1).
SolutionContexts.Item(1);
        CM = dte.Solution.Projects.Item(1).ConfigurationManager;
        Proj = _applicationObject.Solution.Projects.Item(1);
        Cfgs = _applicationObject.Solution.
SolutionBuild.SolutionConfigurations;
        Cfg = (SolutionConfiguration2)Cfgs.Item(1);
        // List the current solution build info.
        msg = "BuildState = ";
        switch (SB.BuildState)
        {
            case vsBuildState.vsBuildStateNotStarted:
                msg = (msg + "Build has not yet started." + "\n");
            break;
            case vsBuildState.vsBuildStateInProgress:
                msg = (msg + "Build is in progress." + "\n");
            break;
            case vsBuildState.vsBuildStateDone:
                msg = (msg + "Build has completed." + "\n");
            break;
        }
        msg = msg + "Configuration Name = " + 
SolCtx.ConfigurationName + "\n";
        msg = msg + "Platform Name = " + SolCtx.PlatformName + "\n";
        msg = msg + "Project Name = " + SolCtx.ProjectName + "\n";
        MessageBox.Show(msg);
        // List the current solution configurations.
        msg = "Configuration names are:" + "\n";
        foreach(SolutionConfiguration2 tempConfigs in Cfgs)
        {
            msg = msg + tempConfigs.Name + "\n";
        }
        MessageBox.Show(msg);
        // Add a new solution configuration.
        Cfgs.Add("ANewConfiguration", "Debug", false);
        MessageBox.Show
("The name of the first solution configuration item is: " 
+ Cfgs.Item(1).Name);
        // Create a new project build configuration based on the 
        // Debug configuration.
        Proj.ConfigurationManager.AddConfigurationRow
("MyNewConfig", "Debug", true);
        // Build the debug solution configuration.
        MessageBox.Show("Build the solution in the debug mode...");
        SB.SolutionConfigurations.Item("Debug").Activate();
        SB.Build(true);
    }
    catch (Exception ex)
    {
        MessageBox.Show("Exception: " + ex);
    }
}

Compilando o código

Para compilar este código, crie um novo projeto Suplemento do Visual Studio e substitua o código da classe Connect.cs ou Connect.vb pelo código no exemplo. Antes de executar o suplemento, abra um projeto no IDE Visual Studio. Para obter informações sobre como executar um suplemento, consulte Como controlar suplementos usando o Gerenciador de Suplementos.

Consulte também

Tarefas

Como adicionar e manipular comandos

Como criar um suplemento

Instruções passo a passo: criando um assistente

Conceitos

Soluções e Projetos

Gráfico do modelo de objetos automation

Outros recursos

Compilando aplicativos no Visual Studio

Criando e controlando janelas de ambiente

Criando suplementos e assistentes

Referência sobre automação e extensibilidade