Erstellen eines grundlegenden Projektsystems, Teil 1

  • Artikel

In Visual Studio sind Projekte die Container, die Entwickler zum Organisieren von Quellcodedateien und anderen Ressourcen verwenden. Projekte werden als untergeordnete Elemente von Lösungen im Projektmappen-Explorer angezeigt. Mit Projekten können Sie Quellcode organisieren, erstellen, debuggen und bereitstellen und Verweise auf Webdienste, Datenbanken und andere Ressourcen erstellen.

Projekte werden in Projektdateien definiert, z. B. eine CSPROJ-Datei für ein Visual C#-Projekt. Sie können ihren eigenen Projekttyp erstellen, der über die Erweiterung für die Projektdatei verfügt. Weitere Informationen zu Projekttypen finden Sie unter Project-Typen.

Hinweis

Wenn Sie Visual Studio mit einem benutzerdefinierten Projekttyp erweitern müssen, empfehlen wir dringend, das Visual Studio-Projektsystem (VSPS) zu nutzen, das eine Reihe von Vorteilen hat, um ein Projektsystem von Grund auf neu zu erstellen:

  • Einfacheres Onboarding. Selbst ein grundlegendes Projektsystem erfordert zehntausende Codezeilen. Die Nutzung von VSPS reduziert die Onboarding-Kosten auf ein paar Klicks, bevor Sie sie an Ihre Anforderungen anpassen können.

  • Einfachere Standard. Durch die Nutzung von VSPS müssen Sie nur Ihre eigenen Szenarien Standard. Wir behandeln den Erhalt aller Projektsysteminfrastrukturen.

    Wenn Sie auf Versionen von Visual Studio abzielen müssen, die älter als Visual Studio 2013 sind, können Sie VSPS nicht in einer Visual Studio-Erweiterung nutzen. Wenn dies der Fall ist, ist diese exemplarische Vorgehensweise ein guter Einstieg.

In dieser exemplarischen Vorgehensweise wird gezeigt, wie Sie einen Projekttyp erstellen, der die Projektdateierweiterung ".myproj" aufweist. Diese exemplarische Vorgehensweise übernimmt das vorhandene Visual C#-Projektsystem.

Hinweis

Weitere Beispiele für Erweiterungsprojekte finden Sie unter VSSDK-Beispiele.

In dieser exemplarischen Vorgehensweise erfahren Sie, wie Sie diese Aufgaben ausführen:

  • Erstellen Sie einen einfachen Projekttyp.

  • Erstellen Sie eine einfache Projektvorlage.

  • Registrieren Sie die Projektvorlage bei Visual Studio.

  • Erstellen Sie eine Projektinstanz, indem Sie das Dialogfeld "Neues Projekt " öffnen und dann die Vorlage verwenden.

  • Erstellen Sie eine Projektfactory für Ihr Projektsystem.

  • Erstellen Sie einen Projektknoten für Ihr Projektsystem.

  • Fügen Sie benutzerdefinierte Symbole für das Projektsystem hinzu.

  • Implementieren Sie die grundlegende Ersetzung von Vorlagenparametern.

Voraussetzungen

Laden Sie den Quellcode für das Verwaltete Paketframework für Projekte herunter. Extrahieren Sie die Datei an einen Speicherort, auf den Sie für die Lösung zugreifen können, die Sie erstellen möchten.

Erstellen eines grundlegenden Projekttyps

Erstellen Sie ein C#VSIX-Projekt mit dem Namen "SimpleProject". (File>New>Project and then Visual C#>Extensibility>VSIX Project). Fügen Sie eine Visual Studio Package-Projektelementvorlage hinzu (klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektknoten, und wählen Sie "Neues Element hinzufügen>" aus, und wechseln Sie dann zur Erweiterbarkeit>von Visual Studio-Paket. Nennen Sie die Datei "SimpleProjectPackage".

Erstellen einer einfachen Projektvorlage

Jetzt können Sie dieses grundlegende VSPackage ändern, um den neuen Myproj-Projekttyp zu implementieren. Um ein Projekt zu erstellen, das auf dem Projekttyp ".myproj " basiert, muss Visual Studio wissen, welche Dateien, Ressourcen und Verweise dem neuen Projekt hinzugefügt werden sollen. Um diese Informationen bereitzustellen, fügen Sie Projektdateien in einen Projektvorlagenordner ein. Wenn ein Benutzer das MYPROJ-Projekt zum Erstellen eines Projekts verwendet, werden die Dateien in das neue Projekt kopiert.

So erstellen Sie eine einfache Projektvorlage

  1. Fügen Sie dem Projekt drei Ordner hinzu, eine unter der anderen: Templates\Projects\SimpleProject. (In klicken Sie Projektmappen-Explorer mit der rechten Maustaste auf den Projektknoten "SimpleProject", zeigen Sie auf "Hinzufügen", und klicken Sie dann auf "Neuer Ordner". Benennen Sie den Ordner "Vorlagen". Fügen Sie im Ordner "Vorlagen" einen Ordner mit dem Namen "Projekte" hinzu. Fügen Sie im Ordner "Projekte" einen Ordner mit dem Namen "SimpleProject" hinzu.)

  2. Fügen Sie im Ordner "Vorlagen\Projekte\SimpleProject " eine Bitmapbilddatei hinzu, die als Symbol mit dem Namen "SimpleProject.ico" verwendet werden soll. Wenn Sie auf "Hinzufügen" klicken, wird der Symbol-Editor geöffnet.

  3. Machen Sie das Symbol unverwechselbar. Dieses Symbol wird später in der exemplarischen Vorgehensweise im Dialogfeld "Neues Projekt " angezeigt.

    Simple Project Icon

  4. Speichern Sie das Symbol, und schließen Sie den Symbol-Editor.

  5. Fügen Sie im Ordner "Vorlagen\Projects\SimpleProject " ein Klassenelement namens "Program.cs" hinzu.

  6. Ersetzen Sie den vorhandenen Code durch die folgenden Zeilen.

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

    Wichtig

    Dies ist nicht die endgültige Form des Program.cs-Codes . Die Ersetzungsparameter werden in einem späteren Schritt behandelt. Möglicherweise werden Kompilierungsfehler angezeigt, aber solange die BuildAction der Datei Inhalt ist, sollten Sie in der Lage sein, das Projekt wie gewohnt zu erstellen und auszuführen.

  7. Speichern Sie die Datei .

  8. Kopieren Sie die Datei "AssemblyInfo.cs " aus dem Ordner "Eigenschaften" in den Ordner "Projects\SimpleProject ".

  9. Fügen Sie im Ordner "Projects\SimpleProject " eine XML-Datei mit dem Namen "SimpleProject.myproj" hinzu.

    Hinweis

    Die Dateinamenerweiterung für alle Projekte dieses Typs lautet ".myproj". Wenn Sie sie ändern möchten, müssen Sie sie überall ändern, wo sie in der exemplarischen Vorgehensweise Erwähnung wird.

  10. Ersetzen Sie den vorhandenen Inhalt durch die folgenden Zeilen.

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

  11. Speichern Sie die Datei .

  12. Legen Sie im Eigenschaftenfenster die Buildaktion von "AssemblyInfo.cs", "Program.cs", "SimpleProject.ico" und "SimpleProject.myproj" auf "Content" fest, und legen Sie deren Include in VSIX-Eigenschaften auf "True" fest.

    Diese Projektvorlage beschreibt ein einfaches Visual C#-Projekt mit einer Debugkonfiguration und einer Releasekonfiguration. Das Projekt enthält zwei Quelldateien, AssemblyInfo.cs und Program.cs und mehrere Assemblyverweise. Wenn ein Projekt aus der Vorlage erstellt wird, wird der ProjectGuid-Wert automatisch durch eine neue GUID ersetzt.

    In Projektmappen-Explorer sollte der erweiterte Vorlagenordner wie folgt angezeigt werden:

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

Erstellen einer grundlegenden Projektfactory

Sie müssen Visual Studio den Speicherort des Projektvorlagenordners mitteilen. Fügen Sie dazu der VSPackage-Klasse ein Attribut hinzu, das die Projektfactory implementiert, sodass der Vorlagenspeicherort bei der Erstellung des VSPackage-Elements in die Systemregistrierung geschrieben wird. Erstellen Sie zunächst eine grundlegende Projektfactory, die durch eine Projektfactory-GUID identifiziert wird. Verwenden Sie das ProvideProjectFactoryAttribute Attribut, um die Projektfactory mit der SimpleProjectPackage Klasse zu verbinden.

So erstellen Sie eine grundlegende Projektfactory

  1. Erstellen Sie GUIDs für Ihre Projektfactory (klicken Sie im Menü "Extras " auf "GUID erstellen"), oder verwenden Sie die GUID im folgenden Beispiel. Fügen Sie die GUIDs der SimpleProjectPackage Klasse in der Nähe des Abschnitts mit dem bereits definierten PackageGuidStringhinzu. Die GUIDs müssen sowohl in GUID-Formular als auch in Zeichenfolgenform enthalten sein. Der resultierende Code sollte dem folgenden Beispiel ähneln.

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

  2. Fügen Sie dem obersten Ordner "SimpleProjectFactory.cs" eine Klasse hinzu.

  3. Fügen Sie die folgenden using-Direktiven hinzu:

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

  4. Fügen Sie der SimpleProjectFactory Klasse ein GUID-Attribut hinzu. Der Wert des Attributs ist die neue Projektfactory-GUID.

    [Guid(SimpleProjectPackage.SimpleProjectFactoryString)]
class SimpleProjectFactory
{
}

    Jetzt können Sie Ihre Projektvorlage registrieren.

So registrieren Sie die Projektvorlage

  1. Fügen Sie in "SimpleProjectPackage.cs" wie folgt ein ProvideProjectFactoryAttribute Attribut zur SimpleProjectPackage Klasse hinzu.

    [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

  2. Erstellen Sie die Lösung neu, und stellen Sie sicher, dass sie ohne Fehler erstellt wird.

    Durch die Neuerstellung wird die Projektvorlage registriert.

    Die Parameter defaultProjectExtension und possibleProjectExtensions werden auf die Projektdateierweiterung (MYPROJ) festgelegt. Der projectTemplatesDirectory Parameter wird auf den relativen Pfad des Vorlagenordners festgelegt. Während des Builds wird dieser Pfad in einen vollständigen Build konvertiert und der Registrierung hinzugefügt, um das Projektsystem zu registrieren.

Testen der Vorlagenregistrierung

Die Vorlagenregistrierung weist Visual Studio den Speicherort des Projektvorlagenordners an, damit Visual Studio den Vorlagennamen und das Symbol im Dialogfeld "Neues Projekt " anzeigen kann.

So testen Sie die Vorlagenregistrierung

  1. Drücken Sie F5 , um mit dem Debuggen einer experimentellen Instanz von Visual Studio zu beginnen.

  2. Erstellen Sie in der experimentellen Instanz ein neues Projekt des neu erstellten Projekttyps. Im Dialogfeld "Neues Projekt" sollte "SimpleProject" unter "Installierte Vorlagen" angezeigt werden.

    Jetzt haben Sie eine Projektfactory, die registriert ist. Es kann jedoch noch kein Projekt erstellt werden. Das Projektpaket und die Projektfactory arbeiten zusammen, um ein Projekt zu erstellen und zu initialisieren.

Hinzufügen des Codes für das verwaltete Paketframework

Implementieren Sie die Verbindung zwischen dem Projektpaket und der Projektfactory.

  • Importieren Sie die Quellcodedateien für das verwaltete Paketframework.

    1. Entladen Sie das SimpleProject-Projekt (wählen Sie in Projektmappen-Explorer den Projektknoten aus, und klicken Sie im Kontextmenü auf "Projekt entladen". Öffnen Sie die Projektdatei im XML-Editor.

    2. Fügen Sie der Projektdatei (direkt oberhalb der Importblöcke>) <die folgenden Blöcke hinzu. Legen Sie ProjectBasePath den Speicherort der Datei "ProjectBase.files " im soeben heruntergeladenen Verwalteten Paketframework-Code fest. Möglicherweise müssen Sie dem Pfadnamen einen umgekehrten Schrägstrich hinzufügen. Wenn Sie dies nicht tun, kann das Projekt den Quellcode des Managed Package Framework nicht finden.

      <PropertyGroup>
     <ProjectBasePath>your path here\</ProjectBasePath>
     <RegisterWithCodebase>true</RegisterWithCodebase>
  </PropertyGroup>
  <Import Project="$(ProjectBasePath)\ProjectBase.Files" />

      Wichtig

      Vergessen Sie nicht den umgekehrten Schrägstrich am Ende des Pfads.

    3. Laden Sie das Projekt neu.

    4. Fügen Sie Verweise auf die folgenden Assemblys hinzu:

      • Microsoft.VisualStudio.Designer.Interfaces (in <VSSDK install>\VisualStudioIntegration\Common\Assemblies\v2.0)

      • WindowsBase

      • Microsoft.Build.Tasks.v4.0

So initialisieren Sie die Projektfactory

  1. Fügen Sie in der Datei "SimpleProjectPackage.cs " die folgende using Direktive hinzu.

    using Microsoft.VisualStudio.Project;

  2. Leiten Sie die SimpleProjectPackage Klasse von Microsoft.VisualStudio.Package.ProjectPackage.

    public sealed class SimpleProjectPackage : ProjectPackage

  3. Registrieren Sie die Projektfactory. Fügen Sie der Methode unmittelbar nach der Methode die folgende Zeile SimpleProjectPackage.Initialize hinzu base.Initialize.

    base.Initialize();
this.RegisterProjectFactory(new SimpleProjectFactory(this));

  4. Implementieren der abstrakten Eigenschaft ProductUserContext:

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

  5. Fügen Sie in SimpleProjectFactory.cs die folgende using Direktive nach den vorhandenen using Direktiven hinzu.

    using Microsoft.VisualStudio.Project;

  6. Leiten Sie die SimpleProjectFactory Klasse von ProjectFactory.

    class SimpleProjectFactory : ProjectFactory

  7. Fügen Sie der Klasse die folgende Dummy-Methode hinzu SimpleProjectFactory . Sie implementieren diese Methode in einem späteren Abschnitt.

    protected override ProjectNode CreateProject()
{
    return null;
}

  8. Fügen Sie der Klasse das folgende Feld und den SimpleProjectFactory folgenden Konstruktor hinzu. Dieser SimpleProjectPackage Verweis wird in einem privaten Feld zwischengespeichert, sodass er beim Festlegen einer Dienstanbieterwebsite verwendet werden kann.

    private SimpleProjectPackage package;

public SimpleProjectFactory(SimpleProjectPackage package)
    : base(package)
{
    this.package = package;
}

  9. Erstellen Sie die Lösung neu, und stellen Sie sicher, dass sie ohne Fehler erstellt wird.

Testen der Projektfactoryimplementierung

Testen Sie, ob der Konstruktor für die Projektfactoryimplementierung aufgerufen wird.

So testen Sie die Projektfactoryimplementierung

  1. Legen Sie in der Datei "SimpleProjectFactory.cs " einen Haltepunkt in der folgenden Zeile im SimpleProjectFactory Konstruktor fest.

    this.package = package;

  2. Drücken Sie F5 , um eine experimentelle Instanz von Visual Studio zu starten.

  3. Beginnen Sie in der experimentellen Instanz mit dem Erstellen eines neuen Projekts. Wählen Sie im Dialogfeld "Neues Projekt " den Projekttyp "SimpleProject " aus, und klicken Sie dann auf "OK". Die Ausführung hält am Haltepunkt an.

  4. Löschen Sie den Haltepunkt, und beenden Sie das Debuggen. Da wir noch keinen Projektknoten erstellt haben, löst der Projekterstellungscode weiterhin Ausnahmen aus.

Erweitern der ProjectNode-Klasse

Jetzt können Sie die SimpleProjectNode Klasse implementieren, die von der ProjectNode Klasse abgeleitet wird. Die ProjectNode Basisklasse behandelt die folgenden Aufgaben der Projekterstellung:

  • Kopiert die Projektvorlagendatei "SimpleProject.myproj" in den neuen Projektordner. Die Kopie wird entsprechend dem Namen umbenannt, der im Dialogfeld "Neues Projekt " eingegeben wird. Der ProjectGuid Eigenschaftswert wird durch eine neue GUID ersetzt.

  • Durchläuft die MSBuild-Elemente der Projektvorlagendatei SimpleProject.myproj und sucht nach Compile Elementen. Kopiert die Datei für jede Compile Zieldatei in den neuen Projektordner.

    Die abgeleitete SimpleProjectNode Klasse behandelt diese Aufgaben:

  • Ermöglicht das Erstellen oder Auswählen von Symbolen für Projekt- und Dateiknoten in Projektmappen-Explorer.

  • Ermöglicht die Angabe zusätzlicher Projektvorlagenparameterersetzungen.

So erweitern Sie die ProjectNode-Klasse

  1. Fügen Sie eine Klasse namens SimpleProjectNode.cshinzu.

  2. Ersetzen Sie den vorhandenen Code durch folgenden Code:

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

    Diese SimpleProjectNode Klassenimplementierung weist die folgenden überschriebenen Methoden auf:

  • ProjectGuid, die die Projektfactory-GUID zurückgibt.

  • ProjectType, der den lokalisierten Namen des Projekttyps zurückgibt.

  • AddFileFromTemplate, die ausgewählte Dateien aus dem Vorlagenordner in das Zielprojekt kopiert. Diese Methode wird weiter in einem späteren Abschnitt implementiert.

    Der SimpleProjectNode Konstruktor wie der SimpleProjectFactory Konstruktor speichert einen SimpleProjectPackage Verweis in einem privaten Feld zur späteren Verwendung zwischen.

    Um die SimpleProjectFactory Klasse mit der SimpleProjectNode Klasse zu verbinden, müssen Sie ein neues SimpleProjectNode in der SimpleProjectFactory.CreateProject Methode instanziieren und in einem privaten Feld zwischenspeichern, um sie später zu verwenden.

So verbinden Sie die Project Factory-Klasse und die Knotenklasse

  1. Fügen Sie in der Datei "SimpleProjectFactory.cs " die folgende using Direktive hinzu:

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

  2. Ersetzen Sie die SimpleProjectFactory.CreateProject Methode durch den folgenden Code.

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

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

  3. Erstellen Sie die Lösung neu, und stellen Sie sicher, dass sie ohne Fehler erstellt wird.

Testen der ProjectNode-Klasse

Testen Sie die Projektfactory, um festzustellen, ob eine Projekthierarchie erstellt wird.

So testen Sie die ProjectNode-Klasse

  1. Drücken Sie die Taste F5 , um mit dem Debuggen zu beginnen. Erstellen Sie in der experimentellen Instanz ein neues SimpleProject.

  2. Visual Studio sollte Ihre Projektfactory aufrufen, um ein Projekt zu erstellen.

  3. Schließen Sie die experimentelle Instanz von Visual Studio.

Hinzufügen eines benutzerdefinierten Projektknotensymbols

Das Projektknotensymbol im vorherigen Abschnitt ist ein Standardsymbol. Sie können es in ein benutzerdefiniertes Symbol ändern.

So fügen Sie ein benutzerdefiniertes Projektknotensymbol hinzu

  1. Fügen Sie im Ordner "Ressourcen " eine Bitmapdatei namens "SimpleProjectNode.bmp" hinzu.

  2. Reduzieren Sie in den Eigenschaftenfenstern die Bitmap auf 16 x 16 Pixel. Gestalten Sie die Bitmap unverwechselbar.

    Simple Project Comm

  3. Ändern Sie im Eigenschaftenfenster die Buildaktion der Bitmap in "Eingebettete Ressource".

  4. Fügen Sie in "SimpleProjectNode.cs" die folgenden using Direktiven hinzu:

    using System.Drawing;
using System.Windows.Forms;

  5. Fügen Sie der Klasse das folgende statische Feld und den SimpleProjectNode folgenden Konstruktor hinzu.

    private static ImageList imageList;

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

  6. Fügen Sie die folgende Eigenschaft am Anfang der SimpleProjectNode Klasse hinzu.

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

  7. Ersetzen Sie den Instanzkonstruktor durch den folgenden Code.

    public SimpleProjectNode(SimpleProjectPackage package)
{
    this.package = package;

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

    foreach (Image img in imageList.Images)
    {
        this.ImageHandler.AddImage(img);
    }
}

    Ruft während der statischen Konstruktion SimpleProjectNode die Projektknotenbitmap aus den Assemblymanifestressourcen ab und speichert sie in einem privaten Feld zur späteren Verwendung zwischen. Beachten Sie die Syntax des GetManifestResourceStream Bildpfads. Verwenden Sie die GetManifestResourceNames Methode, um die Namen der in einer Assembly eingebetteten Manifestressourcen anzuzeigen. Wenn diese Methode auf die SimpleProject Assembly angewendet wird, sollten die Ergebnisse wie folgt lauten:

  • 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

    Während der Instanzkonstruktion lädt die ProjectNode Basisklasse Resources.imagelis.bmp, in die häufig verwendete 16 x 16 Bitmaps aus Resources\imagelis.bmp eingebettet sind. Diese Bitmapliste wird SimpleProjectNode als ImageHandler.ImageList. SimpleProjectNode fügt die Projektknotenbitmap an die Liste an. Der Offset der Projektknotenbitmap in der Bildliste wird zur späteren Verwendung als Wert der öffentlichen ImageIndex Eigenschaft zwischengespeichert. Visual Studio verwendet diese Eigenschaft, um zu bestimmen, welche Bitmap als Projektknotensymbol angezeigt werden soll.

Testen des Benutzerdefinierten Projektknotensymbols

Testen Sie Die Projektfactory, um festzustellen, ob eine Projekthierarchie mit dem benutzerdefinierten Projektknotensymbol erstellt wird.

So testen Sie das symbol für den benutzerdefinierten Projektknoten

  1. Starten Sie das Debuggen, und erstellen Sie in der experimentellen Instanz ein neues SimpleProject.

  2. Beachten Sie im neu erstellten Projekt, dass SimpleProjectNode.bmp als Projektknotensymbol verwendet wird.

    Simple Project New Project Node

  3. Öffnen Sie Program.cs im Code-Editor. Sie sollten Quellcode sehen, der dem folgenden Code ähnelt.

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

    Beachten Sie, dass die Vorlagenparameter $nameSpace$ und $className$ keine neuen Werte enthalten. Im nächsten Abschnitt erfahren Sie, wie Sie die Ersetzung von Vorlagenparametern implementieren.

Ersatzvorlagenparameter

In einem früheren Abschnitt haben Sie die Projektvorlage mit Visual Studio mithilfe des ProvideProjectFactory Attributs registriert. Wenn Sie den Pfad eines Vorlagenordners auf diese Weise registrieren, können Sie die Ersetzung grundlegender Vorlagenparameter aktivieren, indem Sie die ProjectNode.AddFileFromTemplate Klasse überschreiben und erweitern. Weitere Informationen finden Sie unter "Neue Projektgeneration: Unter der Haube, Teil 2".

Fügen Sie nun der Klasse Ersatzcode hinzu AddFileFromTemplate .

So ersetzen Sie Vorlagenparameter

  1. Fügen Sie in der Datei "SimpleProjectNode.cs " die folgende using Direktive hinzu.

    using System.IO;

  2. Ersetzen Sie die AddFileFromTemplate Methode durch den folgenden Code.

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

  3. Legen Sie einen Haltepunkt in der Methode direkt hinter der className Zuordnungsanweisung fest.

    Die Zuordnungsanweisungen bestimmen angemessene Werte für einen Namespace und einen neuen Klassennamen. Die beiden ProjectNode.FileTemplateProcessor.AddReplace Methodenaufrufe ersetzen die entsprechenden Vorlagenparameterwerte mithilfe dieser neuen Werte.

Testen der Vorlagenparameterersetzung

Jetzt können Sie die Ersetzung von Vorlagenparametern testen.

So testen Sie die Ersetzung des Vorlagenparameters

  1. Starten Sie das Debuggen, und erstellen Sie in der experimentellen Instanz ein neues SimpleProject.

  2. Die Ausführung wird an dem Haltepunkt in der AddFileFromTemplate Methode beendet.

  3. Überprüfen Sie die Werte für die nameSpace und className die Parameter.

    • nameSpace erhält den Wert des <RootNamespace-Elements> in der Projektvorlagendatei \Templates\Projects\SimpleProject\SimpleProject.myproj . In diesem Fall handelt es sich um den Wert MyRootNamespace.

    • className erhält den Wert des Klassenquelldateinamens, ohne die Dateinamenerweiterung. In diesem Fall ist die erste Datei, die in den Zielordner kopiert werden soll, " AssemblyInfo.cs". Daher lautet AssemblyInfoder Wert von "className" .

  4. Entfernen Sie den Haltepunkt, und drücken Sie F5 , um die Ausführung fortzusetzen.

    Visual Studio sollte mit dem Erstellen eines Projekts fertig gestellt werden.

  5. Öffnen Sie Program.cs im Code-Editor. Sie sollten Quellcode sehen, der dem folgenden Code ähnelt.

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

    Beachten Sie, dass der Namespace jetzt MyRootNamespace ist und der Klassenname jetzt Programist.

  6. Beginnen Sie mit dem Debuggen des Projekts. Das neue Projekt sollte im Konsolenfenster "Hello VSX!!" kompilieren, ausführen und anzeigen.

    Simple Project Command

    Herzlichen Glückwunsch! Sie haben ein grundlegendes verwaltetes Projektsystem implementiert.