Créer un système de projet de base, partie 2

Article
03/10/2023

La première procédure pas à pas de cette série, Créer un système de projet de base, partie 1, montre comment créer un système de projet de base. Cette procédure pas à pas s’appuie sur le système de projet de base en ajoutant un modèle Visual Studio, une page de propriétés et d’autres fonctionnalités. Vous devez effectuer la première procédure pas à pas avant de commencer celle-ci.

Cette procédure pas à pas explique comment créer un type de projet avec l’extension de nom de fichier projet .myproj. Pour effectuer la procédure pas à pas, vous n’avez pas besoin de créer votre propre langage, car la procédure pas à pas emprunte à partir du système de projet Visual C# existant.

Cette procédure pas à pas explique comment effectuer ces tâches :

Créez un modèle Visual Studio.
Déployez un modèle Visual Studio.
Créez un nœud enfant de type de projet dans la boîte de dialogue Nouveau projet .
Activez la substitution de paramètre dans le modèle Visual Studio.
Créez une page de propriétés de projet.

Remarque

Les étapes décrites dans cette procédure pas à pas sont basées sur un projet C#. Toutefois, à l’exception des spécificités telles que les extensions de nom de fichier et le code, vous pouvez utiliser les mêmes étapes pour un projet Visual Basic.

Créer un modèle Visual Studio

Créer un système de projet de base, partie 1 montre comment créer un modèle de projet de base et l’ajouter au système de projet. Il montre également comment inscrire ce modèle auprès de Visual Studio à l’aide de l’attribut ProvideProjectFactoryAttribute , qui écrit le chemin complet du dossier \Templates\Projects\SimpleProject\ dans le registre système.

En utilisant un modèle Visual Studio (fichier .vstemplate ) au lieu d’un modèle de projet de base, vous pouvez contrôler la façon dont le modèle apparaît dans la boîte de dialogue Nouveau projet et comment les paramètres de modèle sont remplacés. Un fichier .vstemplate est un fichier XML qui décrit comment les fichiers sources doivent être inclus lorsqu’un projet est créé à l’aide du modèle de système de projet. Le système de projet lui-même est généré en collectant le fichier .vstemplate et les fichiers sources dans un fichier .zip , et déployé en copiant le fichier .zip vers un emplacement connu pour Visual Studio. Ce processus est expliqué plus en détail plus loin dans cette procédure pas à pas.

Dans Visual Studio, ouvrez la solution SimpleProject que vous avez créée en suivant Créer un système de projet de base, partie 1.
Dans le fichier SimpleProjectPackage.cs , recherchez l’attribut ProvideProjectFactory. Remplacez le deuxième paramètre (nom du projet) par null et le quatrième paramètre (chemin d’accès au dossier du modèle de projet) par « \\NullPath », comme suit.
```
[ProvideProjectFactory(typeof(SimpleProjectFactory), null,
    "Simple Project Files (*.myproj);*.myproj", "myproj", "myproj",
    ".\\NullPath",
LanguageVsTemplate = "SimpleProject")]
```
Ajoutez un fichier XML nommé SimpleProject.vstemplate au dossier \Templates\Projects\SimpleProject\ .

Remplacez le contenu de SimpleProject.vstemplate par le code suivant.

<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>

Dans la fenêtre Propriétés , sélectionnez les cinq fichiers dans le dossier \Templates\Projects\SimpleProject\ et définissez l’action de génération sur ZipProject.

La <section TemplateData> détermine l’emplacement et l’apparence du type de projet SimpleProject dans la boîte de dialogue Nouveau projet , comme suit :

L’élément <Name> nomme le modèle de projet comme Application SimpleProject.
L’élément <Description> contient la description qui apparaît dans la boîte de dialogue Nouveau projet lorsque le modèle de projet est sélectionné.
L’élément <Icon> spécifie l’icône qui s’affiche avec le type de projet SimpleProject.
L’élément <ProjectType> nomme le type Project dans la boîte de dialogue Nouveau projet . Ce nom remplace le paramètre nom du projet de l’attribut ProvideProjectFactory.

Remarque

L’élément <ProjectType> doit correspondre à l’argument LanguageVsTemplate de l’attribut ProvideProjectFactory dans le fichier SimpleProjectPackage.cs.

La <section TemplateContent> décrit ces fichiers générés lors de la création d’un projet :
SimpleProject.myproj
Program.cs
AssemblyInfo.cs

Les trois fichiers ont ReplaceParameters la valeur true, ce qui permet la substitution de paramètre. Le fichier Program.cs a OpenInEditor la valeur true, ce qui entraîne l’ouverture du fichier dans l’éditeur de code lorsqu’un projet est créé.

Pour plus d’informations sur les éléments du schéma de modèle Visual Studio, consultez la référence du schéma de modèle Visual Studio.

Remarque

Si un projet possède plusieurs modèles Visual Studio, chaque modèle se trouve dans un dossier distinct. Chaque fichier de ce dossier doit avoir l’action de génération définie sur ZipProject.

Ajout d’un fichier .vsct minimal

Visual Studio doit être exécuté en mode d’installation pour reconnaître un modèle Visual Studio nouveau ou modifié. Le mode d’installation nécessite qu’un fichier .vsct soit présent. Par conséquent, vous devez ajouter un fichier .vsct minimal au projet.

Ajoutez un fichier XML nommé SimpleProject.vsct au projet SimpleProject.

Remplacez le contenu du fichier SimpleProject.vsct par le code suivant.

<?xml version="1.0" encoding="utf-8" ?>
<CommandTable
  xmlns="http://schemas.microsoft.com/VisualStudio/2005-10-18/CommandTable">
</CommandTable>

Définissez l’action de génération de ce fichier sur VSCTCompile. Vous ne pouvez le faire que dans le fichier .csproj , et non dans la fenêtre Propriétés . Vérifiez que l’action de génération de ce fichier est définie sur None à ce stade.
1. Cliquez avec le bouton droit sur le nœud SimpleProject, puis cliquez sur Modifier SimpleProject.csproj.
2. Dans le fichier .csproj , recherchez l’élément SimpleProject.vsct .
```
<None Include="SimpleProject.vsct" />
```
3. Remplacez l’action de génération par VSCTCompile.
```
<VSCTCompile Include="SimpleProject.vsct" />
```
4. le fichier projet et fermez l’éditeur.
5. Enregistrez le nœud SimpleProject, puis, dans le Explorateur de solutions cliquez sur Recharger le projet.

Examiner les étapes de génération du modèle Visual Studio

Le système de génération de projet VSPackage exécute généralement Visual Studio en mode d’installation lorsque le fichier .vstemplate est modifié ou que le projet qui contient le fichier .vstemplate est reconstruit. Vous pouvez suivre en définissant le niveau de détail de MSBuild sur Normal ou supérieur.

Dans le menu Outils, cliquez sur Options.
Développez le nœud Projets et solutions , puis sélectionnez Générer et exécuter.
Définissez le détail de sortie de génération du projet MSBuild sur Normal. Cliquez sur OK.
Regénérer le projet SimpleProject.

L’étape de génération pour créer le fichier projet .zip doit ressembler à l’exemple suivant.

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 ->

Déployer un modèle Visual Studio

Les modèles Visual Studio ne contiennent pas d’informations de chemin d’accès. Par conséquent, le fichier .zip de modèle doit être déployé à un emplacement connu pour Visual Studio. L’emplacement du dossier ProjectTemplates est généralement <%LOCALAPPDATA%>\Microsoft\VisualStudio\14.0Exp\ProjectTemplates.

Pour déployer votre fabrique de projet, le programme d’installation doit disposer de privilèges d’administrateur. Il déploie des modèles sous le nœud d’installation de Visual Studio : ...\Microsoft Visual Studio 14.0\Common7\IDE\ProjectTemplates.

Tester un modèle Visual Studio

Testez votre fabrique de projet pour voir s’il crée une hiérarchie de projet à l’aide du modèle Visual Studio.

Réinitialisez l’instance expérimentale du Kit de développement logiciel (SDK) Visual Studio.

Sous Windows 7 : dans le menu Démarrer, recherchez le dossier Microsoft Visual Studio/Kit de développement logiciel (SDK) Microsoft Visual Studio/Tools, puis sélectionnez Réinitialiser l’instance Expérimentale de Microsoft Visual Studio.

Sur les versions ultérieures de Windows : sur l’écran de démarrage, tapez Réinitialiser l’instance expérimentale de version> de Microsoft Visual Studio<.
Une fenêtre d’invite de commandes s’affiche. Lorsque vous voyez les mots Appuyez sur n’importe quelle touche pour continuer, cliquez sur Entrée. Une fois la fenêtre fermée, ouvrez Visual Studio.
Régénérez le projet SimpleProject et démarrez le débogage. L’instance expérimentale s’affiche.
Dans l’instance expérimentale, créez un projet SimpleProject. Dans la boîte de dialogue Nouveau projet , sélectionnez SimpleProject.
Vous devez voir une nouvelle instance de SimpleProject.

Créer un nœud enfant de type de projet

Vous pouvez ajouter un nœud enfant à un nœud de type projet dans la boîte de dialogue Nouveau projet . Par exemple, pour le type de projet SimpleProject, vous pouvez avoir des nœuds enfants pour les applications console, les applications fenêtres, les applications web, et ainsi de suite.

Les nœuds enfants sont créés en modifiant le fichier projet et en ajoutant <des enfants OutputSubPath> aux <éléments ZipProject> . Lorsqu’un modèle est copié pendant la génération ou le déploiement, chaque nœud enfant devient un sous-dossier du dossier des modèles de projet.

Cette section montre comment créer un nœud enfant console pour le type de projet SimpleProject.

Renommez le dossier \Templates\Projects\SimpleProject\ en \Templates\Projects\ConsoleApp\.
Dans la fenêtre Propriétés, sélectionnez les cinq fichiers dans le dossier \Templates\Projects\ConsoleApp\ et vérifiez que l’action de génération est définie sur ZipProject.
Dans le fichier SimpleProject.vstemplate, ajoutez la ligne suivante à la fin de la <section TemplateData> , juste avant la balise de fermeture.
```
<NumberOfParentCategoriesToRollUp>1</NumberOfParentCategoriesToRollUp>
```
Cela entraîne l’affichage du modèle d’application console à la fois dans le nœud enfant de la console et dans le nœud parent SimpleProject, qui est un niveau au-dessus du nœud enfant.
Enregistrez le fichier SimpleProject.vstemplate .
Dans le fichier .csproj , ajoutez <OutputSubPath> à chacun des éléments ZipProject. Déchargez le projet, comme précédemment, puis modifiez le fichier projet.

Recherchez les <éléments ZipProject> . Pour chaque <élément ZipProject> , ajoutez un <élément OutputSubPath> et donnez-lui la valeur Console. The 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>

Ajoutez ce <PropertyGroup> au fichier projet :

<PropertyGroup>
  <VsTemplateLanguage>SimpleProject</VsTemplateLanguage>
</PropertyGroup>

Enregistrez le fichier projet et rechargez le projet.

Tester le nœud enfant du type de projet

Testez le fichier projet modifié pour voir si le nœud enfant de la console apparaît dans la boîte de dialogue Nouveau projet .

Exécutez l’outil Réinitialiser l’outil Microsoft Visual Studio Experimental Instance .
Régénérez le projet SimpleProject et démarrez le débogage. L’instance expérimentale doit apparaître
Dans la boîte de dialogue Nouveau projet , cliquez sur le nœud SimpleProject . Le modèle d’application console doit apparaître dans le volet Modèles .
Développez le nœud SimpleProject . Le nœud enfant de la console doit apparaître. Le modèle d’application SimpleProject continue d’apparaître dans le volet Modèles .
Cliquez sur Annuler et arrêter le débogage.

Remplacer les paramètres du modèle de projet

La création d’un système de projet de base, partie 1 a montré comment remplacer la ProjectNode.AddFileFromTemplate méthode pour effectuer un type de substitution de paramètre de modèle de base. Cette section explique comment utiliser les paramètres de modèle Visual Studio plus sophistiqués.

Lorsque vous créez un projet à l’aide d’un modèle Visual Studio dans la boîte de dialogue Nouveau projet, les paramètres de modèle sont remplacés par des chaînes pour personnaliser le projet. Un paramètre de modèle est un jeton spécial qui commence et se termine par un signe dollar, par exemple, $time$. Les deux paramètres suivants sont particulièrement utiles pour activer la personnalisation dans les projets basés sur le modèle :

$GUID[1-10]$ est remplacé par un nouveau GUID. Vous pouvez spécifier jusqu’à 10 GUID uniques, par exemple, $guid 1$.
$safeprojectname$ est le nom fourni par un utilisateur dans la boîte de dialogue Nouveau projet , modifié pour supprimer tous les caractères et espaces non sécurisés.

Pour obtenir la liste complète des paramètres de modèle, consultez Paramètres de modèle.

Pour remplacer les paramètres de modèle de projet

Dans le fichier SimpleProjectNode.cs , supprimez la AddFileFromTemplate méthode.
Dans le fichier \Templates\Projects\ConsoleApp\SimpleProject.myproj , recherchez la <propriété RootNamespace> et remplacez sa valeur par $safeprojectname$.
```
<RootNamespace>$safeprojectname$</RootNamespace>
```

Dans le fichier \Templates\Projects\SimpleProject\Program.cs , remplacez le contenu du fichier par le code suivant :

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

Régénérez le projet SimpleProject et démarrez le débogage. L’instance expérimentale doit apparaître.
Créez une application console SimpleProject. (Dans le Volet Types de projet , sélectionnez SimpleProject. Sous modèles installés par Visual Studio, sélectionnez Application console.)

Dans le projet nouvellement créé, ouvrez Program.cs. Il doit ressembler à ce qui suit (les valeurs GUID de votre fichier diffèrent).) :

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

Créer une page de propriétés de projet

Vous pouvez créer une page de propriétés pour votre type de projet afin que les utilisateurs puissent afficher et modifier les propriétés dans les projets basés sur votre modèle. Cette section vous montre comment créer une page de propriétés indépendantes de la configuration. Cette page de propriétés de base utilise une grille de propriétés pour afficher les propriétés publiques que vous exposez dans votre classe de page de propriétés.

Dérivez votre classe de page de propriétés de la SettingsPage classe de base. La grille des propriétés fournie par la classe est consciente de la SettingsPage plupart des types de données primitifs et sait comment les afficher. En outre, la SettingsPage classe sait comment conserver les valeurs de propriété dans le fichier projet.

La page de propriétés que vous créez dans cette section vous permet de modifier et d’enregistrer ces propriétés de projet :

AssemblyName
OutputType
RootNamespace.

Dans le fichier SimpleProjectPackage.cs , ajoutez cet ProvideObject attribut à la SimpleProjectPackage classe :
```
[ProvideObject(typeof(GeneralPropertyPage))]
public sealed class SimpleProjectPackage : ProjectPackage
```
Cette opération inscrit la classe GeneralPropertyPage de page de propriétés auprès de COM.

Dans le fichier SimpleProjectNode.cs , ajoutez ces deux méthodes substituées à la 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;
}

Ces deux méthodes retournent un tableau de GUID de page de propriétés. Le GUID GeneralPropertyPage est le seul élément du tableau. La boîte de dialogue Pages de propriétés affiche donc une seule page.

Ajoutez un fichier de classe nommé GeneralPropertyPage.cs au projet SimpleProject.

Remplacez le contenu de ce fichier à l’aide du code suivant :

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

La GeneralPropertyPage classe expose les trois propriétés publiques AssemblyName, OutputType et RootNamespace. Étant donné que AssemblyName n’a pas de méthode set, il est affiché en tant que propriété en lecture seule. OutputType est une constante énumérée. Elle apparaît donc sous forme de liste déroulante.

La SettingsPage classe de base fournit ProjectMgr la persistance des propriétés. La BindProperties méthode utilise ProjectMgr pour récupérer les valeurs de propriété persistantes et définir les propriétés correspondantes. La ApplyChanges méthode utilise ProjectMgr pour obtenir les valeurs des propriétés et les conserver dans le fichier projet. La méthode de jeu de propriétés a IsDirty la valeur true pour indiquer que les propriétés doivent être conservées. La persistance se produit lorsque vous enregistrez le projet ou la solution.

Régénérez la solution SimpleProject et démarrez le débogage. L’instance expérimentale doit apparaître.
Dans l’instance expérimentale, créez une application SimpleProject.
Visual Studio appelle votre fabrique de projet pour créer un projet à l’aide du modèle Visual Studio. Le nouveau fichier Program.cs est ouvert dans l’éditeur de code.
Cliquez avec le bouton droit sur le nœud du projet dans Explorateur de solutions, puis cliquez sur Propriétés. La boîte de dialogue Pages de propriétés s’affiche.

Tester la page de propriétés du projet

Vous pouvez maintenant tester si vous pouvez modifier et modifier des valeurs de propriété.

Dans la boîte de dialogue Pages de propriétés MyConsoleApplication, remplacez DefaultNamespace par MyApplication.
Sélectionnez la propriété OutputType , puis sélectionnez Bibliothèque de classes.
Cliquez sur Appliquer, puis sur OK.
Rouvrez la boîte de dialogue Pages de propriétés et vérifiez que vos modifications ont été conservées.
Fermez l’instance expérimentale de Visual Studio.
Rouvrez l’instance expérimentale.
Rouvrez la boîte de dialogue Pages de propriétés et vérifiez que vos modifications ont été conservées.
Fermez l’instance expérimentale de Visual Studio.

Partager via