Condividi tramite

Procedura: creare configurazioni della build di soluzioni e progetti

  • Articolo

Aggiornamento: novembre 2007

Il modello di automazione di Visual Studio mette a disposizione oggetti che consentono di controllare le configurazioni della build di progetti e soluzioni. In una configurazione della build della soluzione sono specificate le modalità con cui determinati progetti di una soluzione verranno compilati e, se attivati, distribuiti. Le configurazioni della build di progetti sono elencate nella finestra di dialogo Pagine delle proprietà del progetto. In esse sono elencati tutti i tipi disponibili di compilazione di progetti, ad esempio Debug o Release, e tutte le piattaforme disponibili, ad esempio .Net o Win32. Per ogni combinazione di compilazione e piattaforma esiste una configurazione di progetto, ovvero un insieme di proprietà e impostazioni definite per il progetto.

Gli oggetti della configurazione della build della soluzione sono:

Nome oggetto

Descrizione

Oggetto SolutionBuild2

Utilizzato per generare, pulire e distribuire la configurazione di soluzione attiva.

Oggetto SolutionConfiguration2

Rappresenta un elenco di progetti, e delle relative configurazioni, che devono essere generati.

Insieme SolutionConfigurations

Contiene tutti gli oggetti SolutionConfiguration definiti.

Oggetto SolutionContext

Rappresenta una configurazione di progetto in un oggetto SolutionConfiguration.

Insieme SolutionContexts

Contiene tutti gli oggetti SolutionContext in un oggetto SolutionConfiguration.

Oggetto BuildDependency

Rappresenta un progetto che deve essere generato prima che venga generato il progetto a cui appartiene.

Insieme BuildDependencies

Contiene tutti i progetti che devono essere generati prima che venga generato il progetto a cui appartengono.

Gli oggetti della configurazione della build di progetti sono:

Nome oggetto

Descrizione

Oggetto ConfigurationManager

Rappresenta la configurazione della build e le piattaforme.

Oggetto Configuration

Rappresenta una configurazione, o un insieme di impostazioni di generazione, all'interno di una specifica piattaforma.

Insieme Configurations

Contiene tutti gli oggetti Configuration.

Oggetto OutputGroup

Contiene i file generati dal progetto.

Insieme OutputGroups

Contiene tutti gli oggetti OutputGroup.

Tramite l'utilizzo di questi oggetti è possibile:

  • Creare configurazioni di soluzione, aggiungervi progetti, attivarle ed eliminarle.

  • Generare, eseguire o distribuire qualsiasi progetto incluso in una configurazione di soluzione.

  • Ottenere informazioni sugli oggetti contenuti in una configurazione di progetto o di soluzione.

  • Aggiungere, eliminare o ottenere informazioni sulle dipendenze di generazione del progetto.

Nota:

Le finestre di dialogo e i comandi di menu visualizzati potrebbero non corrispondere a quelli descritti nella Guida in linea in quanto dipendono dall'edizione o dalle impostazioni attive. Queste routine sono state sviluppate con le Impostazioni generali per lo sviluppo attive. Per modificare le impostazioni, scegliere Importa/EsportaImpostazioni dal menu Strumenti. Per ulteriori informazioni, vedere Impostazioni di Visual Studio.

Esempio

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);
    }
}

Compilazione del codice

Per compilare il codice, creare un nuovo progetto di componente aggiuntivo Visual Studio e sostituire il codice della classe Connect.cs o Connect.vb con quello riportato nell'esempio. Prima di eseguire il componente aggiuntivo, aprire un progetto nell'ambiente di sviluppo integrato (IDE) di Visual Studio. Per informazioni su come eseguire un componente aggiuntivo, vedere Procedura: controllare i componenti aggiuntivi con Gestione componenti aggiuntivi.

Vedere anche

Attività

Procedura: aggiungere e gestire comandi

Procedura: creare un componente aggiuntivo

Procedura dettagliata: creazione di una procedura guidata

Concetti

Introduzione a soluzioni, progetti ed elementi

Grafico del modello oggetto di automazione

Altre risorse

Compilazione in Visual Studio

Creazione e controllo delle finestre di ambiente

Creazione di componenti aggiuntivi e di procedure guidate

Riferimenti su extensibility e automazione