Procedura: creare configurazioni di compilazione di soluzioni e progetti

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 compilare, pulire e distribuire la configurazione di soluzione attiva.
Oggetto SolutionConfiguration2	Rappresenta un elenco di progetti, e delle relative configurazioni, che devono essere compilati.
Raccolta SolutionConfigurations	Contiene tutti gli oggetti SolutionConfiguration definiti.
Oggetto SolutionContext	Rappresenta una configurazione di progetto in un oggetto SolutionConfiguration.
Raccolta SolutionContexts	Contiene tutti gli oggetti SolutionContext in un oggetto SolutionConfiguration.
Oggetto BuildDependency	Rappresenta un progetto che deve essere compilato prima che venga compilato il progetto a cui appartiene.
Raccolta BuildDependencies	Contiene tutti i progetti che devono essere compilati prima che venga compilato 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 compilazione, all'interno di una specifica piattaforma.
Raccolta Configurations	Contiene tutti gli oggetti Configuration.
Oggetto OutputGroup	Contiene i file compilati dal progetto.
Raccolta OutputGroups	Contiene tutti gli oggetti OutputGroup.

Tramite l'utilizzo di questi oggetti è possibile:

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

• Compilare, 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 compilazione del progetto.

[!NOTA]

È possibile che le finestre di dialogo e i comandi di menu visualizzati siano diversi da quelli descritti nella Guida a seconda delle impostazioni attive o dell'edizione del programma.Queste procedure 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 sull'esecuzione di un componente aggiuntivo, vedere Procedura: controllare i componenti aggiuntivi tramite Gestione componenti aggiuntivi.

Vedere anche

Attività

Procedura: aggiungere e gestire comandi

Procedura: creare un componente aggiuntivo

Procedura dettagliata: creazione di una procedura guidata

Concetti

Elementi di base di soluzioni e di progetto

Grafico del modello a oggetti di automazione

Altre risorse

Compilazione di applicazioni in Visual Studio

Creazione e controllo delle finestre di ambiente

Creazione di componenti aggiuntivi e di procedure guidate

Riferimenti su Extensibility e automazione