Een basisprojectsysteem maken, deel 2

In de eerste procedure in deze reeks, Een basisprojectsysteem maken, deel 1, ziet u hoe u een basisprojectsysteem maakt. Deze handleiding breidt het basisprojectsysteem uit door een Visual Studio-sjabloon, een eigenschappenpagina en andere functies toe te voegen. Je moet de eerste rondleiding voltooien voordat je aan deze begint.

In deze handleiding leert u hoe u een projecttype maakt met de bestandsnaamextensie .myproj. Als u de handleiding wilt voltooien, hoeft u geen eigen taal te maken omdat de handleiding leent van het bestaande Visual C#-projectsysteem.

In deze walkthrough leert u hoe u deze taken uitvoert:

Maak een Visual Studio-sjabloon.
Een Visual Studio-sjabloon implementeren.
Maak een subknooppunt voor het projecttype in het dialoogvenster Nieuw project.
Schakel parametersubstitutie in de Visual Studio-sjabloon in.
Een projecteigenschapspagina maken.

Opmerking

De stappen in dit scenario zijn gebaseerd op een C#-project. Behalve voor specifieke kenmerken, zoals bestandsnaamextensies en code, kunt u dezelfde stappen gebruiken voor een Visual Basic-project.

Een Visual Studio-sjabloon maken

Een basisprojectsysteem maken, deel 1 laat zien hoe u een basisprojectsjabloon maakt en deze toevoegt aan het projectsysteem. U ziet ook hoe u deze sjabloon registreert bij Visual Studio met behulp van het ProvideProjectFactoryAttribute kenmerk, waarmee het volledige pad van de map \Templates\Projects\SimpleProject\ in het systeemregister wordt geschreven.

Met behulp van een Visual Studio-sjabloon (.vstemplate-bestand ) in plaats van een basisprojectsjabloon kunt u bepalen hoe de sjabloon wordt weergegeven in het dialoogvenster Nieuw project en hoe sjabloonparameters worden vervangen. Een .vstemplate-bestand is een XML-bestand dat beschrijft hoe bronbestanden moeten worden opgenomen wanneer een project wordt gemaakt met behulp van de projectsysteemsjabloon. Het projectsysteem zelf wordt gebouwd door het .vstemplate-bestand en de bronbestanden in een .zip-bestand te verzamelen en geïmplementeerd door het .zip-bestand te kopiëren naar een locatie die bekend is bij Visual Studio. Dit proces wordt verderop in deze walkthrough uitgebreider uitgelegd.

Open de SimpleProject-oplossing in Visual Studio die u hebt gemaakt door een basisprojectsysteem te maken, deel 1.
Zoek in het SimpleProjectPackage.cs bestand het kenmerk ProvideProjectFactory. Vervang de tweede parameter (de projectnaam) door null en de vierde parameter (het pad naar de projectsjabloonmap) door '.\\NullPath', als volgt.
```
[ProvideProjectFactory(typeof(SimpleProjectFactory), null,
    "Simple Project Files (*.myproj);*.myproj", "myproj", "myproj",
    ".\\NullPath",
LanguageVsTemplate = "SimpleProject")]
```
Voeg een XML-bestand met de naam SimpleProject.vstemplate toe aan de map \Templates\Projects\SimpleProject\ .

Vervang de inhoud van SimpleProject.vstemplate door de volgende 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>

Selecteer in het venster Eigenschappen alle vijf de bestanden in de map \Templates\Projects\SimpleProject\ en stel de buildactie in op ZipProject.

De <sectie TemplateData> bepaalt als volgt de locatie en het uiterlijk van het type SimpleProject-project in het dialoogvenster Nieuw project :

Het <element Naam> noemt de projectsjabloon als SimpleProject-toepassing.
Het <element Beschrijving> bevat de beschrijving die wordt weergegeven in het dialoogvenster Nieuw project wanneer de projectsjabloon is geselecteerd.
Het <element Pictogram> geeft het pictogram op dat samen met het type SimpleProject-project wordt weergegeven.
Het <Element ProjectType> noemt het projecttype in het dialoogvenster Nieuw project . Deze naam vervangt de projectnaamparameter van het kenmerk ProvideProjectFactory.

Opmerking

Het <ProjectType-element> moet overeenkomen met het LanguageVsTemplate argument van het ProvideProjectFactory kenmerk in het SimpleProjectPackage.cs-bestand.

In de <sectie TemplateContent> worden deze bestanden beschreven die worden gegenereerd wanneer een nieuw project wordt gemaakt:
SimpleProject.myproj
Program.cs
AssemblyInfo.cs

Alle drie de bestanden zijn ReplaceParameters ingesteld op true, waardoor parameters kunnen worden vervangen. Het Program.cs-bestand is OpenInEditor ingesteld op true, waardoor het bestand wordt geopend in de code-editor wanneer een project wordt gemaakt.

Zie de visual Studio-sjabloonschemareferentie voor meer informatie over de elementen in het Visual Studio-sjabloonschema.

Opmerking

Als een project meer dan één Visual Studio-sjabloon heeft, bevindt elke sjabloon zich in een afzonderlijke map. Voor elk bestand in die map moet de buildactie zijn ingesteld op ZipProject.

Een minimaal VSCT-bestand toevoegen

Visual Studio moet worden uitgevoerd in de installatiemodus om een nieuwe of gewijzigde Visual Studio-sjabloon te herkennen. Voor de installatiemodus moet een VSCT-bestand aanwezig zijn. Daarom moet u een minimaal VSCT-bestand toevoegen aan het project.

Voeg een XML-bestand met de naam SimpleProject.vsct toe aan het SimpleProject-project.

Vervang de inhoud van het bestand SimpleProject.vsct door de volgende code.

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

Stel de Build-actie van dit bestand in op VSCTCompile. U kunt dit alleen doen in het .csproj-bestand , niet in het venster Eigenschappen . Zorg ervoor dat de BuildActie van dit bestand is ingesteld op Geen nu.
1. Klik met de rechtermuisknop op het knooppunt SimpleProject en selecteer Vervolgens SimpleProject.csproj bewerken.
2. Zoek in het bestand .csproj het item SimpleProject.vsct .
```
<None Include="SimpleProject.vsct" />
```
3. Wijzig de buildactie in VSCTCompile.
```
<VSCTCompile Include="SimpleProject.vsct" />
```
4. het projectbestand en sluit de editor.
5. Sla het SimpleProject-knooppunt op en selecteer Project opnieuw laden in Solution Explorer.

De buildstappen voor Visual Studio-sjablonen bekijken

Het BUILD-systeem van het VSPackage-project voert doorgaans Visual Studio uit in de installatiemodus wanneer het .vstemplate-bestand wordt gewijzigd of het project met het .vstemplate-bestand opnieuw wordt opgebouwd. U kunt dit volgen door het uitgebreidheidsniveau van MSBuild in te stellen op Normaal of hoger.

Vouw in het deelvenster Extra>opties de sectie Alle instellingen>Projecten en oplossingen>Build en Run uit.
Stel de uitvoeroptie van het MSBuild-project in op Normaal.

Vouw in het dialoogvenster Tools>Opties de sectie Projecten en Oplossingen>Bouwen en Uitvoeren uit.
Stel de MSBuild-project build-output-gedetailleerdheid in op Normaal en selecteer OK.

Bouw het SimpleProject-project opnieuw.

De buildstap voor het maken van het .zip projectbestand moet er ongeveer uitzien als in het volgende voorbeeld.

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

Een Visual Studio-sjabloon implementeren

Visual Studio-sjablonen bevatten geen padgegevens. Daarom moet het sjabloon -.zip-bestand worden geïmplementeerd op een locatie die bekend is bij Visual Studio. De locatie van de map ProjectTemplates is doorgaans <%LOCALAPPDATA%>\Microsoft\VisualStudio\14.0Exp\ProjectTemplates.

Als u uw projectfactory wilt implementeren, moet het installatieprogramma beheerdersbevoegdheden hebben. Er worden sjablonen geïmplementeerd onder het Installatieknooppunt van Visual Studio: ...\Microsoft Visual Studio 14.0\Common7\IDE\ProjectTemplates.

Een Visual Studio-sjabloon testen

Test uw projectfactory om te zien of er een projecthiërarchie wordt gemaakt met behulp van de Visual Studio-sjabloon.

Stel het experimentele exemplaar van de Visual Studio SDK opnieuw in.

Op Windows 7: Zoek in het menu Start de map Microsoft Visual Studio/Microsoft Visual Studio SDK/Tools en selecteer vervolgens Microsoft Visual Studio Experimenteel exemplaar opnieuw instellen.

In latere versies van Windows: typ op het startschermExperimentele instantie van Microsoft Visual Studio-versie opnieuw instellen<>.
Er wordt een opdrachtpromptvenster weergegeven. Wanneer u de woorden ziet, drukt u op een willekeurige toets om door te gaan, selecteert u ENTER. Nadat het venster is gesloten, opent u Visual Studio.
Bouw het SimpleProject-project opnieuw en begin met foutopsporing. Het experimentele exemplaar wordt weergegeven.
Maak in het experimentele exemplaar een SimpleProject-project. Selecteer SimpleProject in het dialoogvenster Nieuw project.
Je zou een nieuw exemplaar van SimpleProject moeten zien.

Maak een kindknooppunt voor het projecttype

U kunt een subknooppunt toevoegen aan een projecttypeknooppunt in het dialoogvenster Nieuw project. Voor het projecttype SimpleProject kunt u bijvoorbeeld onderliggende knooppunten hebben voor consoletoepassingen, venstertoepassingen, webtoepassingen enzovoort.

Onderliggende knooppunten worden gemaakt door het projectbestand te wijzigen en <OutputSubPath>-elementen toe te voegen aan de <ZipProject-elementen>. Wanneer een sjabloon wordt gekopieerd tijdens het bouwen of implementeren, wordt elk onderliggend knooppunt een submap van de projectsjablonenmap.

In deze sectie ziet u hoe u een onderliggend consoleknooppunt maakt voor het type SimpleProject-project.

Wijzig de naam van de map \Templates\Projects\SimpleProject\ in \Templates\Projects\ConsoleApp\.
Selecteer in het venster Eigenschappen alle vijf de bestanden in de map \Templates\Projects\ConsoleApp\ en controleer of de buildactie is ingesteld op ZipProject.
Voeg in het bestand SimpleProject.vstemplate de volgende regel toe aan het einde van de <sectie TemplateData> , net vóór de afsluitende tag.
```
<NumberOfParentCategoriesToRollUp>1</NumberOfParentCategoriesToRollUp>
```
nl-NL: Dit zorgt ervoor dat de consoletoepassingssjabloon zowel in het onderliggende console-knooppunt als in het bovenliggende SimpleProject-knooppunt wordt weergegeven, dat zich één niveau boven het onderliggende knooppunt bevindt.
Sla het bestand SimpleProject.vstemplate op .
Voeg in het .csproj-bestand<OutputSubPath> toe aan elk van de ZipProject-elementen. Verwijder het project, net als voorheen, en bewerk het projectbestand.

Zoek de <ZipProject-elementen> . Voeg aan elk <ZipProject-element> een <OutputSubPath-element> toe en geef het de waarde Console. Het 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>

Voeg deze <PropertyGroup> toe aan het projectbestand:

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

Sla het projectbestand op en laad het project opnieuw.

Het onderliggende knooppunt van het projecttype testen

Test het gewijzigde projectbestand om te zien of het Consoleknooppunt verschijnt in het dialoogvenster Nieuw project.

Voer het hulpprogramma Experimenteel exemplaar van Microsoft Visual Studio opnieuw instellen uit.
Bouw het SimpleProject-project opnieuw en begin met foutopsporing. Het experimentele exemplaar moet worden weergegeven
Selecteer in het dialoogvenster Nieuw project het knooppunt SimpleProject . De consoletoepassingssjabloon moet worden weergegeven in het deelvenster Sjablonen .
Vouw het SimpleProject-knooppunt uit. Het Consolekindknooppunt moet worden weergegeven. De sjabloon SimpleProject-toepassing wordt nog steeds weergegeven in het deelvenster Sjablonen .
Selecteer Annuleren en stoppen met foutopsporing.

Parameters voor projectsjablonen vervangen

Bij het maken van een basisprojectsysteem liet deel 1 zien hoe u de ProjectNode.AddFileFromTemplate methode overschrijft om een basistype sjabloonparameter te vervangen. In deze sectie leert u hoe u de geavanceerdere parameters voor Visual Studio-sjablonen gebruikt.

Wanneer u een project maakt met behulp van een Visual Studio-sjabloon in het dialoogvenster Nieuw project , worden sjabloonparameters vervangen door tekenreeksen om het project aan te passen. Een sjabloonparameter is een speciaal token dat begint en eindigt met een dollarteken, bijvoorbeeld $time$. De volgende twee parameters zijn vooral handig voor het inschakelen van aanpassingen in projecten die zijn gebaseerd op de sjabloon:

$GUID[1-10]$ wordt vervangen door een nieuwe GUID. U kunt maximaal 10 unieke GUID's opgeven, bijvoorbeeld $guid 1$.
$safeprojectname$ is de naam die wordt opgegeven door een gebruiker in het dialoogvenster Nieuw project , gewijzigd om alle onveilige tekens en spaties te verwijderen.

Zie Sjabloonparameters voor een volledige lijst met sjabloonparameters.

Parameters in project templates vervangen

Verwijder de methode in het AddFileFromTemplate.
Zoek in het bestand \Templates\Projects\ConsoleApp\SimpleProject.myproj de eigenschap RootNamespace< en wijzig de >waarde ervan in $safeprojectname$.
```
<RootNamespace>$safeprojectname$</RootNamespace>
```

Vervang in het bestand \Templates\Projects\SimpleProject\Program.cs de inhoud van het bestand door de volgende 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();
        }
    }
}

Bouw het SimpleProject-project opnieuw en begin met foutopsporing. Het experimentele exemplaar moet worden weergegeven.
Maak een nieuwe SimpleProject-consoletoepassing. (Selecteer SimpleProject in het deelvenster Projecttypen. Selecteer Consoletoepassing onder Geïnstalleerde visual Studio-sjablonen.)

Open Program.cs in het zojuist gemaakte project. Het moet er ongeveer als volgt uitzien (GUID-waarden in uw bestand verschillen.):

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

Een projecteigenschapspagina maken

U kunt een eigenschappenpagina maken voor uw projecttype, zodat gebruikers eigenschappen in projecten kunnen bekijken en wijzigen die zijn gebaseerd op uw sjabloon. In deze sectie wordt beschreven hoe u een configuratie-onafhankelijke eigenschappenpagina maakt. Deze basiseigenschappenpagina maakt gebruik van een eigenschappenraster om de openbare eigenschappen weer te geven die u beschikbaar maakt in de eigenschappenpaginaklasse.

Leid je eigenschappenpaginaklasse af van de SettingsPage basisklasse. Het eigenschappenraster dat door de SettingsPage-klasse wordt geleverd, is bekend met de meeste primitieve gegevenstypen en weet hoe deze moeten worden weergegeven. Bovendien weet de SettingsPage klasse hoe eigenschapswaarden moeten worden bewaard in het projectbestand.

Op de eigenschappenpagina die u in deze sectie maakt, kunt u deze projecteigenschappen wijzigen en opslaan:

AssemblyName
Uitvoertype
RootNamespace.

Voeg in het bestand SimpleProjectPackage.cs dit ProvideObject kenmerk toe aan de SimpleProjectPackage klasse:
```
[ProvideObject(typeof(GeneralPropertyPage))]
public sealed class SimpleProjectPackage : ProjectPackage
```
Hiermee wordt de eigenschappenpagina klasse GeneralPropertyPage geregistreerd bij COM.

Voeg in het bestand SimpleProjectNode.cs deze twee overschreven methoden toe aan de SimpleProjectNode klasse:

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

Beide methoden retourneren een matrix met eigenschappenpagina-GUID's. De GUID GeneralPropertyPage is het enige element in de matrix, dus in het dialoogvenster Eigenschappenpagina's wordt slechts één pagina weergegeven.

Voeg een klassebestand met de naam GeneralPropertyPage.cs toe aan het SimpleProject-project.

Vervang de inhoud van dit bestand door de volgende code te gebruiken:

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

De GeneralPropertyPage klasse toont de drie openbare eigenschappen AssemblyName, OutputType en RootNamespace. Omdat AssemblyName geen ingestelde methode heeft, wordt deze weergegeven als een alleen-lezen eigenschap. OutputType is een geïnventariseerd constante, dus deze wordt weergegeven als vervolgkeuzelijst.

De SettingsPage basisklasse biedt ProjectMgr het behouden van de eigenschappen. De BindProperties methode gebruikt ProjectMgr om de persistente eigenschapswaarden op te halen en de bijbehorende eigenschappen in te stellen. De ApplyChanges methode gebruikt ProjectMgr om de waarden van de eigenschappen op te halen en deze op te slaan in het projectbestand. De methode voor het instellen van eigenschappen wordt ingesteld IsDirty op true om aan te geven dat de eigenschappen moeten worden behouden. Persistentie vindt plaats wanneer u het project of de oplossing opslaat.

Bouw de SimpleProject-oplossing opnieuw en start de foutopsporing. Het experimentele exemplaar zou moeten verschijnen.
Maak in het experimentele exemplaar een nieuwe SimpleProject-toepassing.
Visual Studio roept uw projectfactory aan om een project te maken met behulp van de Visual Studio-sjabloon. Het nieuwe Program.cs-bestand wordt geopend in de code-editor.
Klik met de rechtermuisknop op het projectknooppunt in Solution Explorer en selecteer Eigenschappen. Het dialoogvenster Eigenschappenpagina's wordt weergegeven.

De projecteigenschapspagina testen

U kunt nu testen of u eigenschapswaarden kunt aanpassen.

Wijzig in het dialoogvenster Eigenschappenpagina's van MyConsoleApplication de DefaultNamespace in MyApplication.
Selecteer de eigenschap OutputType en selecteer vervolgens Klassebibliotheek.
Selecteer Toepassen en selecteer vervolgens OK.
Open het dialoogvenster Eigenschappenpagina's opnieuw en controleer of uw wijzigingen zijn behouden.
Sluit het experimentele exemplaar van Visual Studio.
Open het experimentele exemplaar opnieuw.
Open het dialoogvenster Eigenschappenpagina's opnieuw en controleer of uw wijzigingen zijn behouden.
Sluit het experimentele exemplaar van Visual Studio.

Last updated on 2025-12-12

Share via