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

Article
10/10/2023

Dans Visual Studio, les projets sont les conteneurs que les développeurs utilisent pour organiser les fichiers de code source et d’autres ressources. Les projets apparaissent sous forme d’enfants de solutions dans la Explorateur de solutions. Les projets vous permettent d’organiser, de générer, de déboguer et de déployer du code source et de créer des références aux services Web, aux bases de données et à d’autres ressources.

Les projets sont définis dans les fichiers projet, par exemple un fichier .csproj pour un projet Visual C#. Vous pouvez créer votre propre type de projet qui possède votre propre extension de nom de fichier projet. Pour plus d’informations sur les types de projets, consultez Types de projets.

Remarque

Si vous avez besoin d’étendre Visual Studio avec un type de projet personnalisé, nous vous recommandons vivement d’utiliser le système de projet Visual Studio (VSPS) qui présente un certain nombre d’avantages par rapport à la création d’un système de projet à partir de zéro :

Intégration plus facile. Même un système de projet de base nécessite des dizaines de milliers de lignes de code. L’utilisation de VSPS réduit le coût d’intégration à quelques clics avant que vous ne soyez prêt à le personnaliser en fonction de vos besoins.
Maintenance plus facile. En tirant parti de VSPS, vous devez uniquement gérer vos propres scénarios. Nous gérons l’entretien de l’ensemble de l’infrastructure système du projet.

Si vous devez cibler des versions de Visual Studio antérieures à Visual Studio 2013, vous ne pourrez pas tirer parti de VSPS dans une extension Visual Studio. Si c’est le cas, cette procédure pas à pas est un bon endroit pour commencer.

Cette procédure pas à pas vous montre comment créer un type de projet avec l’extension de nom de fichier projet .myproj. Cette procédure pas à pas emprunte à partir du système de projet Visual C# existant.

Remarque

Pour plus d’exemples de projets d’extension, consultez les exemples VSSDK.

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

Créez un type de projet de base.
Créez un modèle de projet de base.
Inscrivez le modèle de projet auprès de Visual Studio.
Créez une instance de projet en ouvrant la boîte de dialogue Nouveau projet , puis en utilisant votre modèle.
Créez une fabrique de projet pour votre système de projet.
Créez un nœud de projet pour votre système de projet.
Ajoutez des icônes personnalisées pour le système de projet.
Implémentez la substitution de paramètre de modèle de base.

Prérequis

Téléchargez le code source de Managed Package Framework pour les projets. Extrayez le fichier à un emplacement accessible à la solution que vous allez créer.

Créer un type de projet de base

Créez un projet VSIX C# nommé SimpleProject. (Nouveau projet de fichier>>, puis projet VSIX Visual C#>Extensibility).> Ajoutez un modèle d’élément de projet de package Visual Studio (sur le Explorateur de solutions, cliquez avec le bouton droit sur le nœud du projet, puis sélectionnez Ajouter>un nouvel élément, puis accédez à Extensibilité>du package Visual Studio). Nommez le fichier SimpleProjectPackage.

Création d’un modèle de projet de base

À présent, vous pouvez modifier ce VSPackage de base pour implémenter le nouveau type de projet .myproj . Pour créer un projet basé sur le type de projet .myproj , Visual Studio doit connaître les fichiers, ressources et références à ajouter au nouveau projet. Pour fournir ces informations, placez les fichiers projet dans un dossier de modèle de projet. Lorsqu’un utilisateur utilise le projet .myproj pour créer un projet, les fichiers sont copiés dans le nouveau projet.

Pour créer un modèle de projet de base

Ajoutez trois dossiers au projet, l’un sous l’autre : Templates\Projects\SimpleProject. (Dans Explorateur de solutions, cliquez avec le bouton droit sur le nœud du projet SimpleProject, pointez sur Ajouter, puis cliquez sur Nouveau dossier. Nommez les modèles de dossier. Dans le dossier Modèles, ajoutez un dossier nommé Projects. Dans le dossier Projects, ajoutez un dossier nommé SimpleProject.)
Dans le dossier Templates\Projects\SimpleProject , ajoutez un fichier image bitmap à utiliser comme icône nommée SimpleProject.ico. Lorsque vous cliquez sur Ajouter, l’éditeur d’icônes s’ouvre.
Rendre l’icône distinctive. Cette icône s’affiche dans la boîte de dialogue Nouveau projet plus loin dans la procédure pas à pas.
Enregistrez l’icône et fermez l’éditeur d’icônes.
Dans le dossier Templates\Projects\SimpleProject , ajoutez un élément de classe nommé Program.cs.
Remplacez le code existant par les lignes suivantes.
```
using System;
using System.Collections.Generic;
using System.Text;

namespace $nameSpace$
{
    public class $className$
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello VSX!!!");
            Console.ReadKey();
        }
    }
}
```
Important

Ce n’est pas la forme finale du code Program.cs ; les paramètres de remplacement seront traités dans une étape ultérieure. Vous pouvez voir des erreurs de compilation, mais tant que buildAction du fichier est content, vous devez être en mesure de générer et d’exécuter le projet comme d’habitude.
Enregistrez le fichier.
Copiez le fichier AssemblyInfo.cs du dossier Propriétés vers le dossier Projects\SimpleProject .
Dans le dossier Projects\SimpleProject , ajoutez un fichier XML nommé SimpleProject.myproj.

Remarque

L’extension de nom de fichier pour tous les projets de ce type est .myproj. Si vous souhaitez le modifier, vous devez le modifier partout où il est mentionné dans la procédure pas à pas.

Remplacez le contenu existant par les lignes suivantes.

<?xml version="1.0" encoding="utf-8" ?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <SchemaVersion>2.0</SchemaVersion>
    <ProjectGuid></ProjectGuid>
    <OutputType>Exe</OutputType>
    <RootNamespace>MyRootNamespace</RootNamespace>
    <AssemblyName>MyAssemblyName</AssemblyName>
    <EnableUnmanagedDebugging>false</EnableUnmanagedDebugging>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
    <DebugSymbols>true</DebugSymbols>
    <OutputPath>bin\Debug\</OutputPath>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
    <DebugSymbols>false</DebugSymbols>
    <OutputPath>bin\Release\</OutputPath>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="mscorlib" />
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="AssemblyInfo.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Program.cs">
      <SubType>Code</SubType>
    </Compile>
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
</Project>

Enregistrez le fichier.
Dans la fenêtre Propriétés, définissez l’actionde génération de AssemblyInfo.cs, Program.cs, SimpleProject.ico et SimpleProject.myproj sur Content, puis définissez leur Include dans les propriétés VSIX sur True.

Ce modèle de projet décrit un projet Visual C# de base qui a à la fois une configuration de débogage et une configuration Release. Le projet comprend deux fichiers sources, AssemblyInfo.cs et Program.cs, et plusieurs références d’assembly. Lorsqu’un projet est créé à partir du modèle, la valeur ProjectGuid est automatiquement remplacée par un nouveau GUID.

Dans Explorateur de solutions, le dossier Modèles développés doit apparaître comme suit :

Templates
   Projects
      SimpleProject
         AssemblyInfo.cs
         Program.cs
         SimpleProject.ico
         SimpleProject.myproj

Créer une fabrique de projet de base

Vous devez indiquer à Visual Studio l’emplacement de votre dossier de modèle de projet. Pour ce faire, ajoutez un attribut à la classe VSPackage qui implémente la fabrique de projet afin que l’emplacement du modèle soit écrit dans le registre système lorsque VSPackage est généré. Commencez par créer une fabrique de projet de base identifiée par un GUID de fabrique de projet. Utilisez l’attribut ProvideProjectFactoryAttribute pour connecter la fabrique de projet à la SimpleProjectPackage classe.

Pour créer une fabrique de projet de base

Créez des GUID pour votre fabrique de projet (dans le menu Outils , cliquez sur Créer un GUID) ou utilisez-en un dans l’exemple suivant. Ajoutez les GUID à la SimpleProjectPackage classe près de la section avec la valeur déjà définie PackageGuidString. Les GUID doivent se trouver sous forme GUID et sous forme de chaîne. Le code résultant doit ressembler à l’exemple suivant.
```
    public sealed class SimpleProjectPackage : Package
    {
        ...
        public const string SimpleProjectPkgString = "96bf4c26-d94e-43bf-a56a-f8500b52bfad";
        public const string SimpleProjectFactoryString = "471EC4BB-E47E-4229-A789-D1F5F83B52D4";

        public static readonly Guid guidSimpleProjectFactory = new Guid(SimpleProjectFactoryString);
    }
```
Ajoutez une classe au dossier SimpleProject supérieur nommé SimpleProjectFactory.cs.

Ajoutez les directives using suivantes :

using System.Runtime.InteropServices;
using Microsoft.VisualStudio.Shell;

Ajoutez un attribut GUID à la SimpleProjectFactory classe. La valeur de l’attribut est le nouveau GUID de fabrique de projet.
```
[Guid(SimpleProjectPackage.SimpleProjectFactoryString)]
class SimpleProjectFactory
{
}
```
Vous pouvez maintenant inscrire votre modèle de projet.

Pour inscrire le modèle de projet

Dans SimpleProjectPackage.cs, ajoutez un ProvideProjectFactoryAttribute attribut à la SimpleProjectPackage classe, comme suit.

[ProvideProjectFactory(    typeof(SimpleProjectFactory),     "Simple Project",
    "Simple Project Files (*.myproj);*.myproj", "myproj", "myproj",
    @"Templates\Projects\SimpleProject",     LanguageVsTemplate = "SimpleProject")]
[Guid(SimpleProjectPackage.PackageGuidString)]
public sealed class SimpleProjectPackage : Package

Régénérez la solution et vérifiez qu’elle génère sans erreur.

La reconstruction inscrit le modèle de projet.

Les paramètres defaultProjectExtension et possibleProjectExtensions sont définis sur l’extension de nom de fichier projet (.myproj). Le projectTemplatesDirectory paramètre est défini sur le chemin relatif du dossier Templates . Pendant la génération, ce chemin d’accès est converti en build complète et ajouté au Registre pour inscrire le système de projet.

Tester l’inscription du modèle

L’inscription de modèle indique à Visual Studio l’emplacement de votre dossier de modèle de projet afin que Visual Studio puisse afficher le nom et l’icône du modèle dans la boîte de dialogue Nouveau projet .

Pour tester l’inscription du modèle

Appuyez sur F5 pour démarrer le débogage d’une instance expérimentale de Visual Studio.
Dans l’instance expérimentale, créez un projet de votre type de projet nouvellement créé. Dans la boîte de dialogue Nouveau projet , vous devez voir SimpleProject sous Modèles installés.

Vous disposez maintenant d’une fabrique de projets inscrite. Toutefois, il ne peut pas encore créer un projet. Le package de projet et la fabrique de projet fonctionnent ensemble pour créer et initialiser un projet.

Ajouter le code Managed Package Framework

Implémentez la connexion entre le package de projet et la fabrique de projet.

Importez les fichiers de code source pour Managed Package Framework.
1. Déchargez le projet SimpleProject (dans Explorateur de solutions, sélectionnez le nœud du projet, puis, dans le menu contextuel, cliquez sur Décharger le projet.) et ouvrez le fichier projet dans l’éditeur XML.
2. Ajoutez les blocs suivants au fichier projet (juste au-dessus des blocs d’importation<>). Définissez ProjectBasePath l’emplacement du fichier ProjectBase.files dans le code Managed Package Framework que vous venez de télécharger. Vous devrez peut-être ajouter une barre oblique inverse au chemin d’accès. Si ce n’est pas le cas, le projet risque d’échouer à trouver le code source managed Package Framework.
```
<PropertyGroup>
     <ProjectBasePath>your path here\</ProjectBasePath>
     <RegisterWithCodebase>true</RegisterWithCodebase>
  </PropertyGroup>
  <Import Project="$(ProjectBasePath)\ProjectBase.Files" />
```
  Important
  
  N’oubliez pas la barre oblique inverse à la fin du chemin.
3. Rechargez le projet.
4. Ajoutez des références aux assemblys suivants :
  - Microsoft.VisualStudio.Designer.Interfaces (dans <Installation VSSDK>\VisualStudioIntegration\Common\Assemblys\v2.0)
  - WindowsBase
  - Microsoft.Build.Tasks.v4.0

Pour initialiser la fabrique de projet

Dans le fichier SimpleProjectPackage.cs , ajoutez la directive suivante using .
```
using Microsoft.VisualStudio.Project;
```
Dérivez la SimpleProjectPackage classe de Microsoft.VisualStudio.Package.ProjectPackage.
```
public sealed class SimpleProjectPackage : ProjectPackage
```
Inscrivez la fabrique de projet. Ajoutez la ligne suivante à la SimpleProjectPackage.Initialize méthode, juste après base.Initialize.
```
base.Initialize();
this.RegisterProjectFactory(new SimpleProjectFactory(this));
```

Implémentez la propriété ProductUserContextabstraite :

public override string ProductUserContext
    {
        get { return ""; }
}

Dans SimpleProjectFactory.cs, ajoutez la directive suivante using après les directives existantes using .
```
using Microsoft.VisualStudio.Project;
```
Dérivez la SimpleProjectFactory classe de ProjectFactory.
```
class SimpleProjectFactory : ProjectFactory
```
Ajoutez la méthode factice suivante à la SimpleProjectFactory classe. Vous allez implémenter cette méthode dans une section ultérieure.
```
protected override ProjectNode CreateProject()
{
    return null;
}
```
Ajoutez le champ et le constructeur suivants à la SimpleProjectFactory classe. Cette SimpleProjectPackage référence est mise en cache dans un champ privé afin qu’elle puisse être utilisée pour définir un site de fournisseur de services.
```
private SimpleProjectPackage package;

public SimpleProjectFactory(SimpleProjectPackage package)
    : base(package)
{
    this.package = package;
}
```
Régénérez la solution et vérifiez qu’elle génère sans erreur.

Tester l’implémentation de la fabrique de projet

Testez si le constructeur de votre implémentation de fabrique de projet est appelé.

Pour tester l’implémentation de la fabrique de projet

Dans le fichier SimpleProjectFactory.cs , définissez un point d’arrêt sur la ligne suivante dans le SimpleProjectFactory constructeur.
```
this.package = package;
```
Appuyez sur F5 pour démarrer une instance expérimentale de Visual Studio.
Dans l’instance expérimentale, commencez à créer un projet. Dans la boîte de dialogue Nouveau projet , sélectionnez le type de projet SimpleProject , puis cliquez sur OK. L’exécution s’interrompt au point d’arrêt.
Effacez le point d’arrêt et arrêtez le débogage. Étant donné que nous n’avons pas encore créé de nœud de projet, le code de création du projet lève toujours des exceptions.

Étendre la classe ProjectNode

Vous pouvez maintenant implémenter la SimpleProjectNode classe, qui dérive de la ProjectNode classe. La ProjectNode classe de base gère les tâches suivantes de création de projet :

Copie le fichier de modèle de projet, SimpleProject.myproj, dans le nouveau dossier du projet. La copie est renommée en fonction du nom entré dans la boîte de dialogue Nouveau projet . La ProjectGuid valeur de propriété est remplacée par un nouveau GUID.
Traverse les éléments MSBuild du fichier de modèle de projet, SimpleProject.myproj et recherche des Compile éléments. Pour chaque Compile fichier cible, copie le fichier dans le nouveau dossier du projet.

La classe dérivée SimpleProjectNode gère ces tâches :
Active les icônes pour les nœuds de projet et de fichier dans Explorateur de solutions à créer ou à sélectionner.
Active les substitutions de paramètres de modèle de projet supplémentaires à spécifier.

Pour étendre la classe ProjectNode

Ajoutez une classe nommée SimpleProjectNode.cs.

Remplacez le code existant par le code ci-dessous.

using System;
using System.Collections.Generic;
using Microsoft.VisualStudio.Project;

namespace SimpleProject
{
    public class SimpleProjectNode : ProjectNode
    {
        private SimpleProjectPackage package;

        public SimpleProjectNode(SimpleProjectPackage package)
        {
            this.package = package;
        }
        public override Guid ProjectGuid
        {
            get { return SimpleProjectPackage.guidSimpleProjectFactory; }
        }
        public override string ProjectType
        {
            get { return "SimpleProjectType"; }
        }

        public override void AddFileFromTemplate(
            string source, string target)
        {
            this.FileTemplateProcessor.UntokenFile(source, target);
            this.FileTemplateProcessor.Reset();
        }
    }
}

Cette SimpleProjectNode implémentation de classe a ces méthodes substituées :

ProjectGuid, qui retourne le GUID de la fabrique de projet.
ProjectType, qui retourne le nom localisé du type de projet.
AddFileFromTemplate, qui copie les fichiers sélectionnés du dossier de modèle vers le projet de destination. Cette méthode est implémentée plus loin dans une section ultérieure.

Le SimpleProjectNode constructeur, comme le SimpleProjectFactory constructeur, met en cache une SimpleProjectPackage référence dans un champ privé pour une utilisation ultérieure.

Pour connecter la SimpleProjectFactory classe à la SimpleProjectNode classe, vous devez instancier une nouvelle SimpleProjectNode dans la SimpleProjectFactory.CreateProject méthode et la mettre en cache dans un champ privé pour une utilisation ultérieure.

Pour connecter la classe de fabrique de projet et la classe de nœud

Dans le fichier SimpleProjectFactory.cs , ajoutez la directive suivante using :

using IOleServiceProvider =    Microsoft.VisualStudio.OLE.Interop.IServiceProvider;

Remplacez la méthode à l’aide SimpleProjectFactory.CreateProject du code suivant.

protected override ProjectNode CreateProject()
{
    SimpleProjectNode project = new SimpleProjectNode(this.package);

    project.SetSite((IOleServiceProvider)        ((IServiceProvider)this.package).GetService(            typeof(IOleServiceProvider)));
    return project;
}

Régénérez la solution et vérifiez qu’elle génère sans erreur.

Tester la classe ProjectNode

Testez votre fabrique de projet pour voir s’il crée une hiérarchie de projet.

Pour tester la classe ProjectNode

Appuyez sur F5 pour démarrer le débogage. Dans l’instance expérimentale, créez un projet SimpleProject.
Visual Studio doit appeler votre fabrique de projet pour créer un projet.
Fermez l’instance expérimentale de Visual Studio.

Ajouter une icône de nœud de projet personnalisé

L’icône de nœud de projet dans la section précédente est une icône par défaut. Vous pouvez le remplacer par une icône personnalisée.

Pour ajouter une icône de nœud de projet personnalisé

Dans le dossier Resources , ajoutez un fichier bitmap nommé SimpleProjectNode.bmp.
Dans les fenêtres Propriétés , réduisez la bitmap à 16 par 16 pixels. Rendre l’image bitmap distinctive.
Dans la fenêtre Propriétés, remplacez l’actionBuild de la bitmap par ressource incorporée.
Dans SimpleProjectNode.cs, ajoutez les directives suivantes using :
```
using System.Drawing;
using System.Windows.Forms;
```

Ajoutez le champ statique et le constructeur suivants à la SimpleProjectNode classe.

private static ImageList imageList;

static SimpleProjectNode()
{
    imageList =        Utilities.GetImageList(            typeof(SimpleProjectNode).Assembly.GetManifestResourceStream(                "SimpleProject.Resources.SimpleProjectNode.bmp"));
}

Ajoutez la propriété suivante au début de la SimpleProjectNode classe.

internal static int imageIndex;
   public override int ImageIndex
   {
       get { return imageIndex; }
   }

Remplacez le constructeur d’instance par le code suivant.
```
public SimpleProjectNode(SimpleProjectPackage package)
{
    this.package = package;

    imageIndex = this.ImageHandler.ImageList.Images.Count;

    foreach (Image img in imageList.Images)
    {
        this.ImageHandler.AddImage(img);
    }
}
```
Pendant la construction statique, SimpleProjectNode récupère la bitmap du nœud de projet à partir des ressources du manifeste d’assembly et la met en cache dans un champ privé pour une utilisation ultérieure. Notez la syntaxe du chemin d’accès de l’image GetManifestResourceStream . Pour afficher les noms des ressources manifeste incorporées dans un assembly, utilisez la GetManifestResourceNames méthode. Lorsque cette méthode est appliquée à l’assembly SimpleProject , les résultats doivent être les suivants :

SimpleProject.Resources.resources
VisualStudio.Project.resources
SimpleProject.VSPackage.resources
Resources.imagelis.bmp
Microsoft.VisualStudio.Project.DontShowAgainDialog.resources
Microsoft.VisualStudio.Project.SecurityWarningDialog.resources
SimpleProject.Resources.SimpleProjectNode.bmp

Pendant la construction de l’instance, la ProjectNode classe de base charge Resources.imagelis.bmp, dans laquelle sont incorporées 16 bitmaps x 16 à partir de Resources\imagelis.bmp. Cette liste bitmap est mise à disposition en SimpleProjectNode tant que ImageHandler.ImageList. SimpleProjectNode ajoute la bitmap du nœud de projet à la liste. Le décalage de la bitmap du nœud de projet dans la liste d’images est mis en cache pour une utilisation ultérieure comme valeur de la propriété publique ImageIndex . Visual Studio utilise cette propriété pour déterminer la bitmap à afficher en tant qu’icône de nœud de projet.

Tester l’icône de nœud de projet personnalisé

Testez votre fabrique de projet pour voir s’il crée une hiérarchie de projets avec votre icône de nœud de projet personnalisé.

Pour tester l’icône de nœud de projet personnalisé

Démarrez le débogage et, dans l’instance expérimentale, créez un nouveau SimpleProject.
Dans le projet nouvellement créé, notez que SimpleProjectNode.bmp est utilisé comme icône de nœud de projet.
Ouvrez Program.cs dans l’éditeur de code. Vous devez voir le code source qui ressemble au code suivant.
```
using System;
using System.Collections.Generic;
using System.Text;

namespace $nameSpace$
{
    public class $className$
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello VSX!!!");
            Console.ReadKey();
        }
    }
}
```
Notez que les paramètres de modèle $nameSpace$ et $className$ n’ont pas de nouvelles valeurs. Vous allez apprendre à implémenter la substitution de paramètre de modèle dans la section suivante.

Remplacer les paramètres du modèle

Dans une section antérieure, vous avez inscrit le modèle de projet auprès de Visual Studio à l’aide de l’attribut ProvideProjectFactory . L’inscription du chemin d’accès d’un dossier de modèle de cette façon vous permet d’activer la substitution de paramètre de modèle de base en remplaçant et en développant la ProjectNode.AddFileFromTemplate classe. Pour plus d’informations, consultez Nouvelle génération de projet : sous le capot, deuxième partie.

Ajoutez maintenant du code de remplacement à la AddFileFromTemplate classe.

Pour remplacer les paramètres de modèle

Dans le fichier SimpleProjectNode.cs , ajoutez la directive suivante using .
```
using System.IO;
```

Remplacez la méthode à l’aide AddFileFromTemplate du code suivant.

public override void AddFileFromTemplate(
    string source, string target)
{
    string nameSpace =
        this.FileTemplateProcessor.GetFileNamespace(target, this);
    string className = Path.GetFileNameWithoutExtension(target);

    this.FileTemplateProcessor.AddReplace("$nameSpace$", nameSpace);
    this.FileTemplateProcessor.AddReplace("$className$", className);

    this.FileTemplateProcessor.UntokenFile(source, target);
    this.FileTemplateProcessor.Reset();
}

Définissez un point d’arrêt dans la méthode, juste après l’instruction d’affectation className .

Les instructions d’affectation déterminent des valeurs raisonnables pour un espace de noms et un nouveau nom de classe. Les deux ProjectNode.FileTemplateProcessor.AddReplace appels de méthode remplacent les valeurs de paramètre de modèle correspondantes à l’aide de ces nouvelles valeurs.

Tester la substitution de paramètre de modèle

Vous pouvez maintenant tester la substitution de paramètre de modèle.

Pour tester la substitution de paramètre de modèle

Démarrez le débogage et, dans l’instance expérimentale, créez un nouveau SimpleProject.
L’exécution s’arrête au point d’arrêt de la AddFileFromTemplate méthode.
Examinez les valeurs des paramètres et className des nameSpace paramètres.
- nameSpace est donné la valeur de l’élément <RootNamespace> dans le fichier de modèle de projet \Templates\Projects\SimpleProject\SimpleProject.myproj . Dans ce cas, la valeur est MyRootNamespace.
- className est donné la valeur du nom de fichier source de la classe, sans l’extension de nom de fichier. Dans ce cas, le premier fichier à copier dans le dossier de destination est AssemblyInfo.cs ; par conséquent, la valeur de className est AssemblyInfo.
Supprimez le point d’arrêt et appuyez sur F5 pour continuer l’exécution.

Visual Studio doit terminer la création d’un projet.

Ouvrez Program.cs dans l’éditeur de code. Vous devez voir le code source qui ressemble au code suivant.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyRootNamespace
{
    public class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello VSX!!!");
            Console.ReadKey();
        }
    }
}

Notez que l’espace de noms est maintenant MyRootNamespace et que le nom de la classe est maintenant Program.

Démarrez le débogage du projet. Le nouveau projet doit compiler, exécuter et afficher « Hello VSX !! » dans la fenêtre de console.

Félicitations ! Vous avez implémenté un système de projet managé de base.