Comment : créer des configurations de génération de solution et de projet

Le modèle Automation Visual Studio propose des objets qui vous permettent de contrôler les configurations de build de projets et de solutions.Une configuration de build de solution spécifie la façon dont certains projets d'une solution doivent être générés, et déployés si l'option correspondante est activée.Les configurations de build de projet, répertoriées dans la boîte de dialogue Pages de propriétés du projet, énumèrent l'ensemble des types de générations de projet disponibles, tels que Debug ou Release, ainsi que les plateformes disponibles, telles que .Net ou Win32.Pour chaque combinaison de génération et de plateforme, il existe une configuration de projet, c'est-à-dire un ensemble de propriétés et de paramètres de projet définis.

Les objets de configuration de build de solution sont les suivants :

Nom de l'objet	Description
Objet SolutionBuild2	Utilisé pour générer, nettoyer et déployer la configuration de solution actuellement active.
Objet SolutionConfiguration2	Représente une liste de projets et leurs configurations qui doivent être générées.
Collection SolutionConfigurations	Contient tous les objets SolutionConfiguration définis.
Objet SolutionContext	Représente la configuration d'un projet dans un objet SolutionConfiguration.
Collection SolutionContexts	Contient tous les objets SolutionContext présents dans un objet SolutionConfiguration.
Objet BuildDependency	Représente un projet qui doit être généré avant que le projet propriétaire puisse être généré.
Collection BuildDependencies	Contient l'ensemble des projets qui doivent être générés avant que le projet propriétaire puisse être généré.

Les objets de configuration de build de projet sont les suivants :

Nom de l'objet	Description
Objet ConfigurationManager	Représente la configuration et les plateformes de build.
Objet Configuration	Représente une configuration, ou un ensemble de paramètres de génération, au sein d'une plateforme spécifiée.
Collection Configurations	Contient tous les objets Configuration.
Objet OutputGroup	Contient les fichiers qui sont générés par le projet.
Collection OutputGroups	Contient tous les objets OutputGroup.

À l'aide de ces objets, vous pouvez :

• créer, activer et supprimer des configurations de solution, ainsi qu'ajouter des projets à des configurations de solution ;

• générer, exécuter ou déployer n'importe quel projet d'une configuration de solution ;

• obtenir des informations sur les objets d'une configuration de solution ou de projet ;

• ajouter, supprimer ou obtenir des informations sur les dépendances d'une génération de projet.

[!REMARQUE]

Les boîtes de dialogue et les commandes de menu qui s'affichent peuvent être différentes de celles qui sont décrites dans l'aide, en fonction de vos paramètres actifs ou de l'édition utilisée.Ces procédures ont été développées avec les paramètres de développement généraux actifs.Pour modifier vos paramètres, sélectionnez Importation et exportationde paramètres dans le menu Outils.Pour plus d'informations, consultez Paramètres Visual Studio.

Exemple

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

Compilation du code

Pour compiler ce code, créez un projet de complément Visual Studio et remplacez le code de la classe Connect.cs ou Connect.vb par le code de l'exemple.Avant d'exécuter le complément, ouvrez un projet dans l'IDE Visual Studio.Pour plus d'informations sur l'exécution d'un complément, consultez Comment : contrôler des compléments avec le Gestionnaire de compléments.

Voir aussi

Tâches

Comment : ajouter et gérer des commandes

Comment : créer un complément

Procédure pas à pas : création d'un Assistant

Concepts

Éléments fondamentaux relatifs à la solution et au projet

Graphique Modèle d'objet Automation

Autres ressources

Génération d'applications dans Visual Studio

Création et contrôle de fenêtres d'environnement

Création de compléments et d'Assistants

Guide de référence de l'extensibilité et de l'automation