Créer un système de projet de base, partie 2Create a basic project system, part 2

La première procédure pas à pas dans 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.The first walkthrough in this series, Create a basic project system, part 1, shows how to create a basic project system. 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 autres fonctionnalités.This walkthrough builds on the basic project system by adding a Visual Studio template, a property page, and other features. Vous devez effectuer la première procédure avant de commencer celle-ci.You must complete the first walkthrough before you start this one.

Cette procédure pas à pas explique comment créer un type de projet qui a l’extension de nom de fichier de projet .myproj.This walkthrough teaches how to create a project type that has the project file name extension .myproj. Pour terminer la procédure pas à pas, il est inutile de créer votre propre langage, car la procédure pas à pas utilise le système de projet Visual c# existant.To complete the walkthrough, you do not have to create your own language because the walkthrough borrows from the existing Visual C# project system.

Cette procédure pas à pas explique comment accomplir ces tâches :This walkthrough teaches how to accomplish these tasks:

  • Créer un modèle de Visual Studio.Create a Visual Studio template.

  • Déployer un modèle de Visual Studio.Deploy a Visual Studio template.

  • Créer un nœud enfant du type projet dans le nouveau projet boîte de dialogue.Create a project type child node in the New Project dialog box.

  • Activer la substitution de paramètre dans le modèle Visual Studio.Enable parameter substitution in the Visual Studio template.

  • Créer une page de propriétés de projet.Create a project property page.

Note

Les étapes décrites dans cette procédure pas à pas sont basées sur un projet c#.The steps in this walkthrough are based on a C# project. Toutefois, à l’exception des caractéristiques telles que les extensions de nom de fichier et le code, vous pouvez utiliser les mêmes étapes pour un projet Visual Basic.However, except for specifics such as file name extensions and code, you can use the same steps for a Visual Basic project.

Créer un modèle Visual StudioCreate a Visual Studio template

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.Create a basic project system, part 1 shows how to create a basic project template and add it to the project system. Il montre également comment inscrire ce modèle avec Visual Studio à l’aide de la ProvideProjectFactoryAttribute attribut, qui écrit le chemin d’accès complet de le \Templates\Projects\SimpleProject\ dossier dans le système Registre.It also shows how to register this template with Visual Studio by using the ProvideProjectFactoryAttribute attribute, which writes the full path of the \Templates\Projects\SimpleProject\ folder in the system registry.

À l’aide d’un modèle Visual Studio (.vstemplate fichier) au lieu d’un modèle de projet de base, vous pouvez contrôler la façon dont le modèle apparaît dans le nouveau projet boîte de dialogue et comment les paramètres de modèle remplacée.By using a Visual Studio template (.vstemplate file) instead of a basic project template, you can control how the template appears in the New Project dialog box and how template parameters are substituted. Un .vstemplate fichier est un fichier XML qui décrit la façon dont les fichiers sources doivent être inclus lorsqu’un projet est créé en utilisant le modèle de système de projet.A .vstemplate file is an XML file that describes how source files are to be included when a project is created by using the project system template. Le système de projet lui-même est généré en collectant les .vstemplate fichier et les fichiers source dans un .zip de fichiers et déployées en copiant le .zip vers un emplacement qui est connus pour Visual Studio.The project system itself is built by collecting the .vstemplate file and the source files in a .zip file, and deployed by copying the .zip file to a location that is known to Visual Studio. Ce processus est expliqué en détail plus loin dans cette procédure pas à pas.This process is explained in more detail later in this walkthrough.

  1. Dans Visual StudioVisual Studio, ouvrez la solution SimpleProject que vous avez créé en suivant créer un système de projet de base, partie 1.In Visual StudioVisual Studio, open the SimpleProject solution that you created by following Create a basic project system, part 1.

  2. Dans le SimpleProjectPackage.cs de fichier, recherchez l’attribut ProvideProjectFactory.In the SimpleProjectPackage.cs file, find the ProvideProjectFactory attribute. Remplacez-les par le deuxième paramètre (le nom du projet), avec NULL comme valeur et le quatrième paramètre (le chemin d’accès au dossier du modèle de projet) ». \\NullPath », comme suit.Replace the second parameter (the project name) with null, and the fourth parameter (the path to the project template folder) with ".\\NullPath", as follows.

    [ProvideProjectFactory(typeof(SimpleProjectFactory), null,  
        "Simple Project Files (*.myproj);*.myproj", "myproj", "myproj",  
        ".\\NullPath",  
    LanguageVsTemplate = "SimpleProject")]  
    
  3. Ajouter un fichier XML nommé SimpleProject.vstemplate à la \Templates\Projects\SimpleProject\ dossier.Add an XML file named SimpleProject.vstemplate to the \Templates\Projects\SimpleProject\ folder.

  4. Remplacez le contenu de SimpleProject.vstemplate avec le code suivant.Replace the contents of SimpleProject.vstemplate with the following code.

    <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>  
    
  5. Dans le propriétés fenêtre, sélectionnez toutes les cinq fichiers dans le \Templates\Projects\SimpleProject\ dossier et appliquez le Action de génération pour ZipProject.In the Properties window, select all five files in the \Templates\Projects\SimpleProject\ folder and set the Build Action to ZipProject.

    Dossier de projet simpleSimple Project Folder

    Le <TemplateData > section détermine l’emplacement et l’apparence du type de projet SimpleProject dans le nouveau projet boîte de dialogue, comme suit :The <TemplateData> section determines the location and appearance of the SimpleProject project type in the New Project dialog box, as follows:

  • Le <nom > le modèle de projet application de SimpleProject noms d’éléments.The <Name> element names the project template to be SimpleProject Application.

  • Le <Description > élément contient la description qui s’affiche dans le nouveau projet boîte de dialogue lorsque le modèle de projet est sélectionné.The <Description> element contains the description that appears in the New Project dialog box when the project template is selected.

  • Le <icône > élément spécifie l’icône qui apparaît avec le type de projet SimpleProject.The <Icon> element specifies the icon that appears together with the SimpleProject project type.

  • Le <ProjectType > élément désigne le type de projet dans le nouveau projet boîte de dialogue.The <ProjectType> element names the Project type in the New Project dialog box. Ce nom remplace le paramètre de nom de projet de l’attribut ProvideProjectFactory.This name replaces the project name parameter of the ProvideProjectFactory attribute.

    Note

    Le <ProjectType > élément doit correspondre à la LanguageVsTemplate argument de la ProvideProjectFactory attribut dans le fichier SimpleProjectPackage.cs.The <ProjectType> element must match the LanguageVsTemplate argument of the ProvideProjectFactory attribute in the SimpleProjectPackage.cs file.

    Le <TemplateContent > section décrit ces fichiers sont générés lorsqu’un nouveau projet est créé :The <TemplateContent> section describes these files that are generated when a new project is created:

  • SimpleProject.myprojSimpleProject.myproj

  • Program.csProgram.cs

  • AssemblyInfo.csAssemblyInfo.cs

    Les trois fichiers ont ReplaceParameters définie sur true, ce qui permet la substitution de paramètres.All three files have ReplaceParameters set to true, which enables parameter substitution. Le Program.cs fichier a OpenInEditor définie sur true, ce qui provoque le fichier à ouvrir dans l’éditeur de code lorsqu’un projet est créé.The Program.cs file has OpenInEditor set to true, which causes the file to be opened in the code editor when a project is created.

    Pour plus d’informations sur les éléments dans le schéma de modèle Visual Studio, consultez le référence de schéma de modèle Visual Studio.For more information about the elements in the Visual Studio Template schema, see the Visual Studio template schema reference.

Note

Si un projet comporte plusieurs modèles de Visual Studio, chaque modèle est dans un dossier distinct.If a project has more than one Visual Studio template, every template is in a separate folder. Chaque fichier dans ce dossier doit posséder le Action de génération définie sur ZipProject.Every file in that folder must have the Build Action set to ZipProject.

Ajout d’un fichier .vsct minimaleAdding a minimal .vsct file

Visual Studio doit être exécuté en mode d’installation pour reconnaître un modèle Visual Studio nouvel ou modifié.Visual Studio must be run in setup mode to recognize a new or modified Visual Studio template. Le mode d’installation nécessite un .vsct fichier qui doit être présent.Setup mode requires a .vsct file to be present. Par conséquent, vous devez ajouter un minimale .vsct fichier au projet.Therefore, you must add a minimal .vsct file to the project.

  1. Ajouter un fichier XML nommé SimpleProject.vsct au projet SimpleProject.Add an XML file named SimpleProject.vsct to the SimpleProject project.

  2. Remplacez le contenu de la SimpleProject.vsct fichier par le code suivant.Replace the contents of the SimpleProject.vsct file with the following code.

    <?xml version="1.0" encoding="utf-8" ?>  
    <CommandTable  
      xmlns="http://schemas.microsoft.com/VisualStudio/2005-10-18/CommandTable">  
    </CommandTable>  
    
  3. Définir le Action de génération de ce fichier à VSCTCompile.Set the Build Action of this file to VSCTCompile. Cela peut uniquement dans le .csproj de fichiers, pas dans le propriétés fenêtre.You can do this only in the .csproj file, not in the Properties window. Assurez-vous que le Action de génération de ce fichier est défini sur aucun à ce stade.Make sure that the Build Action of this file is set to None at this point.

    1. Cliquez sur le nœud SimpleProject et puis cliquez sur SimpleProject.csproj modifier.Right-click the SimpleProject node and then click Edit SimpleProject.csproj.

    2. Dans le .csproj de fichiers, recherchez le SimpleProject.vsct élément.In the .csproj file, locate the SimpleProject.vsct item.

      <None Include="SimpleProject.vsct" />  
      
    3. Modifier l’action de génération pour VSCTCompile.Change the build action to VSCTCompile.

      <VSCTCompile Include="SimpleProject.vsct" />  
      
    4. le fichier projet et le fermer l’éditeur.the project file and close the editor.

    5. Enregistrer le nœud SimpleProject, puis, dans le l’Explorateur de solutions cliquez sur recharger le projet.Save the SimpleProject node, and then in the Solution Explorer click Reload Project.

Examinez les étapes de build de modèle Visual StudioExamine the Visual Studio template build steps

Le système de génération de projet VSPackage s’exécute généralement Visual Studio en mode d’installation lors de la .vstemplate fichier est modifié ou le projet qui contient le .vstemplate fichier est régénéré.The VSPackage project build system typically runs Visual Studio in setup mode when the .vstemplate file is changed or the project that contains the .vstemplate file is rebuilt. Vous pouvez suivre la procédure en définissant le niveau de détail de MSBuild à la normale ou une version ultérieure.You can follow along by setting the verbosity level of MSBuild to Normal or higher.

  1. Dans le menu Outils , cliquez sur Options.On the Tools menu, click Options.

  2. Développez le projets et Solutions nœud, puis sélectionnez générer et exécuter.Expand the Projects and Solutions node, and then select Build and Run.

  3. Définissez niveau de détail de sortie de génération de projet MSBuild à Normal.Set MSBuild project build output verbosity to Normal. Cliquez sur OK.Click OK.

  4. Régénérez le projet SimpleProject.Rebuild the SimpleProject project.

    L’étape de build pour créer le .zip fichier projet doit ressembler à l’exemple suivant.The build step to create the .zip project file should resemble the following example.

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 StudioDeploy a Visual Studio template

Modèles Visual Studio ne contiennent pas les informations de chemin d’accès.Visual Studio templates do not contain path information. Par conséquent, le modèle .zip fichier doit être déployé vers un emplacement connu pour Visual Studio.Therefore, the template .zip file must be deployed to a location that is known to Visual Studio. L’emplacement du dossier ProjectTemplates est généralement < % LocalAppData% > \Microsoft\VisualStudio\14.0Exp\ProjectTemplates.The location of the ProjectTemplates folder is typically <%LOCALAPPDATA%>\Microsoft\VisualStudio\14.0Exp\ProjectTemplates.

Pour déployer votre fabrique de projet, le programme d’installation doit avoir des privilèges d’administrateur.To deploy your project factory, the installation program must have administrator privileges. Il déploie des modèles sous le nœud d’installation de Visual Studio : ...\Microsoft Visual Studio 14.0\Common7\IDE\ProjectTemplates.It deploys templates under the Visual Studio installation node: ...\Microsoft Visual Studio 14.0\Common7\IDE\ProjectTemplates.

Tester un modèle Visual StudioTest a Visual Studio template

Tester votre fabrique de projet pour voir si elle crée une hiérarchie de projet en utilisant le modèle Visual Studio.Test your project factory to see whether it creates a project hierarchy by using the Visual Studio template.

  1. Réinitialiser l’instance expérimentale de Visual Studio SDK.Reset the Visual Studio SDK experimental instance.

    Sur Windows 7Windows 7: sur le Démarrer menu, trouver la outils Microsoft Visual Studio/Microsoft Visual Studio SDK/ dossier, puis sélectionnez réinitialiser le Microsoft expérimentale Visual Studio instance.On Windows 7Windows 7: On the Start menu, find the Microsoft Visual Studio/Microsoft Visual Studio SDK/Tools folder, and then select Reset the Microsoft Visual Studio Experimental instance.

    Sur les versions ultérieures de Windows : sur le Démarrer , tapez réinitialiser Microsoft Visual Studio <version > Instance expérimentale.On later versions of Windows: On the Start screen, type Reset the Microsoft Visual Studio <version> Experimental Instance.

  2. Une fenêtre d’invite de commandes s’affiche.A command prompt window appears. Lorsque vous voyez les mots appuyez sur n’importe quelle touche pour continuer, cliquez sur entrée.When you see the words Press any key to continue, click ENTER. Une fois que la fenêtre se ferme, ouvrez Visual Studio.After the window closes, open Visual Studio.

  3. Régénérez le projet SimpleProject et démarrer le débogage.Rebuild the SimpleProject project and start debugging. L’instance expérimentale s’affiche.The experimental instance appears.

  4. Dans l’instance expérimentale, créez un projet de SimpleProject.In the experimental instance, create a SimpleProject project. Dans le nouveau projet boîte de dialogue, sélectionnez SimpleProject.In the New Project dialog box, select SimpleProject.

  5. Vous devez voir une nouvelle instance de SimpleProject.You should see a new instance of SimpleProject.

    Nouvelle Instance de projet simpleSimple Project New Instance

    Mon projet nouvelle InstanceMy Project New Instance

Créer un nœud enfant du type de projetCreate a project type child node

Vous pouvez ajouter un nœud enfant à un nœud de type de projet dans le nouveau projet boîte de dialogue.You can add a child node to a project type node in the New Project dialog box. Par exemple, pour le type de projet SimpleProject, vous pouvez avoir des nœuds enfants pour les applications de console, fenêtre applications, applications web et ainsi de suite.For example, for the SimpleProject project type, you could have child nodes for console applications, window applications, web applications, and so on.

Nœuds enfants sont créés en modifiant le fichier projet et en ajoutant <OutputSubPath > enfants à la <ZipProject > éléments.Child nodes are created by altering the project file and adding <OutputSubPath> children to the <ZipProject> elements. Lorsqu’un modèle est copié au cours de génération ou de déploiement, tous les nœuds enfants devient un sous-dossier du dossier de modèles de projet.When a template is copied during build or deployment, every child node becomes a subfolder of the project templates folder.

Cette section montre comment créer un nœud enfant de Console pour le type de projet SimpleProject.This section shows how to create a Console child node for the SimpleProject project type.

  1. Renommer le \Templates\Projects\SimpleProject\ dossier \Templates\Projects\ConsoleApp\.Rename the \Templates\Projects\SimpleProject\ folder to \Templates\Projects\ConsoleApp\.

  2. Dans le propriétés fenêtre, sélectionnez toutes les cinq fichiers dans le \Templates\Projects\ConsoleApp\ dossier et vérifiez que le Action de générationest défini sur ZipProject.In the Properties window, select all five files in the \Templates\Projects\ConsoleApp\ folder and make sure the Build Action is set to ZipProject.

  3. Dans le fichier SimpleProject.vstemplate, ajoutez la ligne suivante à la fin de la <TemplateData > section, juste avant la balise de fermeture.In the SimpleProject.vstemplate file, add the following line at the end of the <TemplateData> section, just before the closing tag.

    <NumberOfParentCategoriesToRollUp>1</NumberOfParentCategoriesToRollUp>  
    

    Cela entraîne le modèle d’Application de Console apparaissent dans le nœud enfant de la Console et dans le nœud parent SimpleProject, ce qui se trouve un niveau au-dessus du nœud enfant.This causes the Console Application template to appear both in the Console child node and in the SimpleProject parent node, which is one level above the child node.

  4. Enregistrer le SimpleProject.vstemplate fichier.Save the SimpleProject.vstemplate file.

  5. Dans le .csproj , ajoutez <OutputSubPath > à chacun des éléments ZipProject.In the .csproj file, add <OutputSubPath> to each of the ZipProject elements. Décharger le projet, comme auparavant et modifiez le fichier projet.Unload the project, as before, and edit the project file.

  6. Recherchez le <ZipProject > éléments.Locate the <ZipProject> elements. À chaque <ZipProject > élément, ajoutez un <OutputSubPath > élément et lui donner la valeur de Console.To each <ZipProject> element, add an <OutputSubPath> element and give it the value Console. Le ZipProjectThe 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>  
    
  7. Ajoutez ce <PropertyGroup > dans le fichier de projet :Add this <PropertyGroup> to the project file:

    <PropertyGroup>  
      <VsTemplateLanguage>SimpleProject</VsTemplateLanguage>  
    </PropertyGroup>  
    
  8. Enregistrez le fichier projet et recharger le projet.Save the project file and reload the project.

Le nœud enfant de type projet de testTest the project type child node

Tester le fichier de projet modifié pour voir si le Console nœud enfant s’affiche dans le nouveau projet boîte de dialogue.Test the modified project file to see whether the Console child node appears in the New Project dialog box.

  1. Exécutez le réinitialiser l’Instance expérimentale Microsoft Visual Studio outil.Run the Reset the Microsoft Visual Studio Experimental Instance tool.

  2. Régénérez le projet SimpleProject et démarrer le débogage.Rebuild the SimpleProject project and start debugging. L’instance expérimentale doit apparaître.The experimental instance should appear

  3. Dans le nouveau projet boîte de dialogue, cliquez sur le SimpleProject nœud.In the New Project dialog, click the SimpleProject node. Le Application Console modèle doit apparaître dans le modèles volet.The Console Application template should appear in the Templates pane.

  4. Développez le SimpleProject nœud.Expand the SimpleProject node. Le Console nœud enfant doit apparaître.The Console child node should appear. Le SimpleProject Application modèle continue d’apparaître dans le modèles volet.The SimpleProject Application template continues to appear in the Templates pane.

  5. Cliquez sur Annuler et arrêter le débogage.Click Cancel and stop debugging.

    Cumul de projet simpleSimple Project Rollup

    Nœud projet simple de la ConsoleSimple Project Console Node

Substituer des paramètres de modèle de projetSubstitute project template parameters

Création d’un système de projet de base, partie 1 vous a montré comment remplacer le ProjectNode.AddFileFromTemplate pour cela un type de base de la substitution de paramètre de modèle.Creating a basic project system, part 1 showed how to overwrite the ProjectNode.AddFileFromTemplate method to do a basic kind of template parameter substitution. Cette section explique comment utiliser les paramètres de modèle Visual Studio plus sophistiquées.This section teaches how to use the more sophisticated Visual Studio template parameters.

Lorsque vous créez un projet à l’aide d’un modèle de Visual Studio dans le nouveau projet boîte de dialogue modèle de paramètres sont remplacés par des chaînes pour personnaliser le projet.When you create a project by using a Visual Studio template in the New Project dialog box, template parameters are replaced with strings to customize the project. Un paramètre de modèle est un jeton spécial qui commence et se termine par un signe dollar, par exemple, $time$.A template parameter is a special token that begins and ends with a dollar sign, for example, $time$. Les deux paramètres suivants sont particulièrement utiles pour l’activation de personnalisation dans les projets qui reposent sur le modèle :The following two parameters are especially useful for enabling customization in projects that are based on the template:

  • $GUID [1-10] $ est remplacé par un nouveau Guid.$GUID[1-10]$ is replaced by a new Guid. Vous pouvez spécifier jusqu'à 10 GUID uniques, par exemple, $guid1$.You can specify up to 10 unique GUIDs, for example, $guid1$.

  • $safeprojectname$ est le nom fourni par un utilisateur dans le nouveau projet boîte de dialogue, modifié afin de supprimer tous les caractères sécurisés et des espaces.$safeprojectname$ is the name provided by a user in the New Project dialog box, modified to remove all unsafe characters and spaces.

    Pour obtenir la liste complète des paramètres de modèle, consultez Paramètres de modèle.For a complete list of template parameters, see Template parameters.

Pour substituer des paramètres de modèle de projetTo substitute project template parameters

  1. Dans le SimpleProjectNode.cs de fichiers, supprimez le AddFileFromTemplate (méthode).In the SimpleProjectNode.cs file, remove the AddFileFromTemplate method.

  2. Dans le \Templates\Projects\ConsoleApp\SimpleProject.myproj de fichiers, recherchez le <RootNamespace > propriété et remplacez sa valeur $safeprojectname$.In the \Templates\Projects\ConsoleApp\SimpleProject.myproj file, locate the <RootNamespace> property and change its value to $safeprojectname$.

    <RootNamespace>$safeprojectname$</RootNamespace>  
    
  3. Dans le \Templates\Projects\SimpleProject\Program.cs de fichier, remplacez le contenu du fichier par le code suivant :In the \Templates\Projects\SimpleProject\Program.cs file, replace the contents of the file with the following code:

    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();  
            }  
        }  
    }  
    
  4. Régénérez le projet SimpleProject et démarrer le débogage.Rebuild the SimpleProject project and start debugging. L’instance expérimentale doit apparaître.The experimental instance should appear.

  5. Créer une nouvelle application de Console de SimpleProject.Create a new SimpleProject Console application. (Dans le types de projets volet, sélectionnez SimpleProject.(In the Project types pane, select SimpleProject. Sous modèles Visual Studio installés, sélectionnez Application Console.)Under Visual Studio installed templates, select Console Application.)

  6. Dans le projet nouvellement créé, ouvrez Program.cs.In the newly-created project, open Program.cs. Il doit se présenter comme suit (les valeurs GUID dans votre fichier diffèrent.) :It should look something like the following (GUID values in your file will differ.):

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

Creatr une page de propriétés de projetCreatr a project property page

Vous pouvez créer une page de propriétés pour votre type de projet afin que les utilisateurs peuvent afficher et modifier les propriétés dans les projets qui sont basés sur votre modèle.You can create a property page for your project type so that users can view and change properties in projects that are based on your template. Cette section vous montre comment créer une page de propriétés indépendantes de la configuration.This section shows you how to create a configuration-independent property page. 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.This basic property page uses a properties grid to display the public properties that you expose in your property page class.

Dérivez votre classe de page de propriété de la SettingsPage classe de base.Derive your property page class from the SettingsPage base class. La grille des propriétés fournie par le SettingsPage classe tient compte des types de données les plus primitifs et sait comment les afficher.The properties grid provided by the SettingsPage class is aware of most primitive data types and knows how to display them. En outre, la SettingsPage classe sait comment conserver les valeurs de propriété au fichier projet.In addition, the SettingsPage class knows how to persist property values to the project file.

La page de propriétés que vous créez dans cette section vous permet de modifier et enregistrer ces propriétés de projet :The property page you create in this section lets you alter and save these project properties:

  • AssemblyNameAssemblyName

  • OutputTypeOutputType

  • RootNamespace.RootNamespace.

  1. Dans le SimpleProjectPackage.cs de fichiers, ajoutez ceci ProvideObject attribut le SimpleProjectPackage classe :In the SimpleProjectPackage.cs file, add this ProvideObject attribute to the SimpleProjectPackage class:

    [ProvideObject(typeof(GeneralPropertyPage))]  
    public sealed class SimpleProjectPackage : ProjectPackage  
    

    Cela inscrit la classe de page de propriété GeneralPropertyPage auprès de COM.This registers the property page class GeneralPropertyPage with COM.

  2. Dans le SimpleProjectNode.cs , ajoutez ces deux méthodes substituées pour la SimpleProjectNode classe :In the SimpleProjectNode.cs file, add these two overridden methods to the SimpleProjectNode class:

    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 la page de propriétés GUID.Both of these methods return an array of property page GUIDs. Le GUID GeneralPropertyPage est le seul élément dans le tableau, donc la Pages de propriétés boîte de dialogue affiche qu’une seule page.The GeneralPropertyPage GUID is the only element in the array, so the Property Pages dialog box will show only one page.

  3. Ajoutez un fichier de classe nommé GeneralPropertyPage.cs au projet SimpleProject.Add a class file named GeneralPropertyPage.cs to the SimpleProject project.

  4. Remplacez le contenu de ce fichier en utilisant le code suivant :Replace the contents of this file by using the following code:

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

    Le GeneralPropertyPage classe expose trois propriétés publiques AssemblyName et OutputType RootNamespace.The GeneralPropertyPage class exposes the three public properties AssemblyName, OutputType, and RootNamespace. AssemblyName n’ayant aucune méthode set, il est affiché comme une propriété en lecture seule.Because AssemblyName has no set method, it is displayed as a read-only property. OutputType est une constante énumérée, afin qu’il apparaisse en tant que liste déroulante.OutputType is an enumerated constant, so it appears as dropdown list.

    Le SettingsPage fournit la classe de base ProjectMgr pour rendre persistantes les propriétés.The SettingsPage base class provides ProjectMgr to persist the properties. Le BindProperties méthode utilise ProjectMgr pour récupérer les valeurs de propriété persistante et de définir les propriétés correspondantes.The BindProperties method uses ProjectMgr to retrieve the persisted property values and set the corresponding properties. Le ApplyChanges méthode utilise ProjectMgr pour obtenir les valeurs des propriétés et les conserver dans le fichier projet.The ApplyChanges method uses ProjectMgr to get the values of the properties and persist them to the project file. La propriété set définit de la méthode IsDirty comme « true » pour indiquer que les propriétés devaient être rendues persistantes.The property set method sets IsDirty to true to indicate that the properties have to be persisted. Persistance se produit lorsque vous enregistrez le projet ou la solution.Persistence occurs when you save the project or solution.

  5. Régénérez la solution SimpleProject et démarrer le débogage.Rebuild the SimpleProject solution and start debugging. L’instance expérimentale doit apparaître.The experimental instance should appear.

  6. Dans l’instance expérimentale, créez une nouvelle Application SimpleProject.In the experimental instance, create a new SimpleProject Application.

  7. Visual Studio appelle votre fabrique de projet pour créer un projet en utilisant le modèle Visual Studio.Visual Studio calls your project factory to create a project by using the Visual Studio template. La nouvelle Program.cs fichier est ouvert dans l’éditeur de code.The new Program.cs file is opened in the code editor.

  8. Cliquez sur le nœud de projet dans l’Explorateur de solutions, puis cliquez sur propriétés.Right-click the project node in Solution Explorer, and then click Properties. La boîte de dialogue Pages de propriétés s’affiche.The Property Pages dialog box is displayed.

    Page de propriétés de projet simpleSimple Project Property Page

La page de propriétés de projet de testTest the project property page

Vous pouvez maintenant tester si vous pouvez modifier et modifier les valeurs de propriété.Now you can test whether you can modify and change property values.

  1. Dans le Pages de propriétés MyConsoleApplication boîte de dialogue, choisissez le DefaultNamespace à MyApplication.In the MyConsoleApplication Property Pages dialog box, change the DefaultNamespace to MyApplication.

  2. Sélectionnez le OutputType propriété, puis sélectionnez bibliothèque de classes.Select the OutputType property, and then select Class Library.

  3. Cliquez sur appliquer, puis cliquez sur OK.Click Apply, and then click OK.

  4. Rouvrez le Pages de propriétés boîte de dialogue zone et vérifier que vos modifications ont été rendues persistantes.Reopen the Property Pages dialog box and verify that your changes have been persisted.

  5. Fermez l’instance expérimentale de Visual Studio.Close the experimental instance of Visual Studio.

  6. Rouvrez l’instance expérimentale.Reopen the experimental instance.

  7. Rouvrez le Pages de propriétés boîte de dialogue zone et vérifier que vos modifications ont été rendues persistantes.Reopen the Property Pages dialog box and verify that your changes have been persisted.

  8. Fermez l’instance expérimentale de Visual Studio.Close the experimental instance of Visual Studio.

    Fermez l’instance expérimentaleClose the experimental instance