Freigeben über

Exemplarische Vorgehensweise: Teil 1: Erstellen eines einfachen Projektsystem

  • Artikel

In Visual Studio sind Projekte die Container, mit denen Entwickler verwenden, um Quellcodedateien und andere Ressourcen zu organisieren, die in Projektmappen-Explorerangezeigt werden. Organisieren von Projekten können Sie Quellcode erstellen, debuggen und bereitstellen und Verweisen auf Webdienste, auf die Datenbanken und anderen Ressourcen erstellen.

In der Regel werden Projekte mit dem Inhalt einer Projektdatei z. B. einer CSPROJ-Datei für ein Visual C#-Projekt angegeben. Sie können erstellen, Projekttyp verfügen, der dateinamenerweiterung Projekt verfügt, besitzen. Weitere Informationen zu Projekttypen finden Sie unter Projekttypen.

In dieser exemplarischen Vorgehensweise unterrichtet, wie Sie einen Projekttyp erstellt, der die dateinamenerweiterung Projekt .myproj verfügt. Zum Durchführen der exemplarischen Vorgehensweise müssen Sie nicht besitzen da die Sprache zu erstellen Bürgschaften der exemplarischen Vorgehensweise aus vorhandenen Visual C#-Projekten Projektsystem.

Hinweis

Für ein mit projektsystems Sprachen eines vollständigen Beispiels finden Sie unter IronPython-Beispiel tiefe Tauchen in Visual Studio-Erweiterbarkeits-Beispiele.

In dieser exemplarischen Vorgehensweise unterrichtet, wie die folgenden Aufgaben ausgeführt werden:

  • Erstellen Sie einen grundlegenden Projekttyp.

  • Erstellen Sie eine grundlegende Projektvorlage.

  • Registrieren Sie die Projektvorlage mit Visual Studio.

  • Erstellen Sie eine Projektinstanz, indem Sie das Dialogfeld Neues Projekt und dann mit der Vorlage öffnen.

  • Erstellen Sie ein Projekt factory für das Projektsystem erstellt.

  • Erstellen Sie einen Projektknoten für das Projektsystem.

  • Hinzufügen benutzerdefinierter Symbole für das Projektsystem hinzugefügt.

  • Grundlegender Vorlagenparameter Ersetzung zu implementieren.

Hinweis

Die Schritte in dieser exemplarischen Vorgehensweise basieren auf einem C#-Projekt.Allerdings außer spezifischen Merkmale wie file name extensions and Code können Sie dieselben Schritte für ein Visual Basic-Projekt verwenden.

Vorbereitungsmaßnahmen

Zum Abschließen dieser exemplarischen Vorgehensweise müssen Sie Visual Studio 2010 SDKinstallieren.

Hinweis

Weitere Informationen über das Visual Studio-SDK finden Sie unter Erweitern von Visual Studio Overview.Um herauszufinden finden Sie unter wie das Visual Studio-SDK, auf Visual Studio Extensibility Developer Center der MSDN-Website herunterlädt.

Speicherorte für die Visual Studio-Paket-Projektvorlage

Die Visual Studio-Paket importieren kann in drei verschiedenen Stellen im Dialogfeld Neues Projekt gefunden werden:

  1. Klicken Sie unter Von Visual Basic-Erweiterbarkeit. Die Standardsprache des Projekts ist Visual Basic.

  2. Die C#-Erweiterbarkeit. Die Standardsprache ist C# des Projekts.

  3. Verwenden anderer Projekttyp-Erweiterbarkeit. Die Standardsprache ist C# des Projekts, VB und C++ sind verfügbar.

Erstellen eines grundlegenden Projekttyp

Projekttypen, wie die meisten Visual Studio-Erweiterungen, werden von VSPackages implementiert. Weitere Informationen zu VSPackages finden Sie unter Exemplarische Vorgehensweisen zum Anpassen von Visual Studio mithilfe von VSPackages. Um einen Projekttyp zu erstellen, müssen Sie zuerst ein VSPackage erstellen.

So erstellen Sie ein VSPackage

  1. Erstellen Sie ein VSPackage-Projekt, das SimpleProject benannt ist.

  2. Wählen Sie auf der Seite Wählen Sie eine Programmiersprache aus.Visual C# und Neue Schlüsseldatei für die Assemblysignierung generierenaus.

  3. Deaktivieren Sie auf der Seite Testoptionen aktivieren beide Optionen, und klicken Sie dann auf Fertig stellen.

    Die Vorlage erstellt ein VSPackage-Projekt, das die angegebenen Einstellungen.

Eine grundlegende Projektvorlage erstellen

Nun können Sie das grundlegende VSPackage ändern, um den neuen .myproj-Projekttyp zu implementieren. Um ein Projekt zu erstellen, das basierend auf dem .myproj-Projekttyp ist, muss Visual Studio wissen, welche Dateien, Ressourcen und dem neuen Projekt Verweise hinzuzufügen. Um diese Informationen bereitzustellen, setzen Sie Projektdateien in einen Ordner Projektvorlagen ein. Wenn ein Benutzer den .myproj-Projekttyp im Dialogfeld Neues Projekt verwendet, um ein Projekt zu erstellen, werden die Dateien in das neue Projekt kopiert.

So erstellen Sie eine grundlegende Projektvorlage erstellen

  1. In Projektmappen-ExplorerSimpleProject mit der rechten Maustaste auf den Projektknoten, zeigen Sie auf Hinzufügen, und klicken Sie dann auf Neuer Ordner. Benennen Sie den Ordner Vorlagen.

  2. Im Vorlagen Ordner fügen Sie einen Ordner mit dem Namen hinzu, der Projekte.

  3. Im Projekte Ordner fügen Sie einen Ordner mit dem Namen hinzu, der SimpleProject.

  4. Klicken Sie mit der rechten Maustaste auf SimpleProject Ordner, zeigen Sie auf Hinzufügen, und klicken Sie dann auf Neues Element. Fügen Sie eine Symboldatei SimpleProject.icohinzu. Klicken Sie auf Hinzufügen Symbol, um den Editor zu öffnen.

  5. Führen Sie das Symbol unterscheidend. Dieses Symbol wird im Neues Projekt Dialogfeld später in der exemplarischen Vorgehensweise.

    Symbol Einfaches Projekt

  6. Speichern Sie das Symbol, und schließen Sie den Symbol des Editors.

  7. Im SimpleProject Ordner fügen Sie ein Klasse-Element hinzu, das Program.csbenannt ist. Klicken Sie auf Hinzufügen , um den Code-Editor zu öffnen.

  8. Ersetzen Sie den vorhandenen Code, indem Sie die folgenden Zeilen verwenden.

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

Hinweis

Die Dateien in der Projektvorlage enthalten möglicherweise Vorlagenparameter, die programmgesteuert geändert werden können, wenn die Dateien in einem neuen Projekt kopiert werden.Im weiteren Verlauf der exemplarischen Vorgehensweise erfahren Sie, wie Sie dies für die Vorlagenparameter $nameSpace$, und $className$ erzielt.

  1. Speichern Sie die Datei, und schließen Sie den Code-Editor.

  2. Im Eigenschaften Ordner fügen Kopie AssemblyInfo.cs und ihn anschließend im Projekte\SimpleProject Ordner ein.

  3. Legen Sie im Fenster Eigenschaften zu KeineAssemblyInfo.cs von Buildvorgang fest.

  4. In Projektmappen-Explorermit der rechten Maustaste auf den Ordner SimpleProject , zeigen Sie auf Hinzufügen, und klicken Sie dann auf Neues Element. Fügen Sie ein XML-Datei-Element SimpleProject.myprojhinzu. Klicken Sie auf Hinzufügen , um den XML-Editor geöffnet werden soll.

    Hinweis

    Die Dateinamenerweiterung für alle Projekte dieses Typs ist .myproj.Wenn Sie sie ändern möchten, müssen Sie sie ändern, eine beliebige Stelle, das zuvor in der exemplarischen Vorgehensweise erwähnt wird.

  5. Ersetzen Sie den vorhandenen Inhalt, indem Sie die folgenden Zeilen verwenden.

    <Project DefaultTargets="Build" xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <SchemaVersion>2.0</SchemaVersion>
    <ProjectGuid>{99999999-9999-9999-9999-999999999999}</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>

  6. Speichern Sie die Datei, und schließen Sie den XML-Editor.

  7. Legen Sie im Fenster EigenschaftenBuildvorgang von Program.cs, SimpleProject.ico und SimpleProject.myproj zu Inhaltfest, und legen Sie ihre jeweiligen Include in VSIXTrueEigenschaften fest.

Diese Projektvorlage beschreibt ein einfaches Visual C#-Projekt, das eine Debugkonfiguration und eine Releasekonfiguration verfügt. Das Projekt enthält zwei Quelldateien AssemblyInfo.cs und Program.cs, und einige Assemblyverweise. Wenn ein Projekt von der Vorlage erstellt wird, wird der GUID ProjectGuid-Wert automatisch durch ein neues ersetzt.

In Projektmappen-Explorersollte der erweiterte Vorlagen Ordner werden folgendermaßen:

Vorlagen

    Projekte

        SimpleProject

            AssemblyInfo.cs

            Program.cs

            SimpleProject.ico

            SimpleProject.myproj

Eine skelettartige erstellen Projekt-Factory

Sie müssen Sie in Visual Studio den Speicherort des Veröffentlichungsordners Projektvorlagen vermitteln. Hierzu fügen Sie ein Attribut der VSPackage-Klasse factory Projekt hinzu, die die Implementierung für den Speicherort der Vorlagen zur Systemregistrierung geschrieben wird, wenn ein VSPackage erstellt wird. Erstellen Sie zunächst eine grundlegende Projekt factorys factory Projekt durch eine GUID gekennzeichnet wird. Verwenden Sie das Attribut, um die ProvideProjectFactoryAttribute factory Projekt eine Verbindung mit der SimpleProjectPackage-Klasse herzustellen.

So erstellen Sie eine skelettartige Projekt factory

  1. Öffnen Sie Guids.cs im Code-Editor.

  2. Zeigen Sie im Menü Extras Klicken Sie auf GUID erstellen.

  3. Erstellen Sie eine GUID für die Projekt factory, oder verwenden Sie die im folgenden Beispiel veranschaulicht. Fügen Sie die GUID des GuidList hinzu. Der GUID muss in beiden Guid-Formular und - Zeichenfolge sein. Der resultierende Code entspricht in etwa dem folgenden Beispiel:

    static class GuidList
{
    public const string guidSimpleProjectPkgString = 
        "96bf4c26-d94e-43bf-a56a-f8500b52bfad";
    public const string guidSimpleProjectCmdSetString = 
        "72c23e1d-f389-410a-b5f1-c938303f1391";
    public const string guidSimpleProjectFactoryString =  
        "471EC4BB-E47E-4229-A789-D1F5F83B52D4";

    public static readonly Guid guidSimpleProjectCmdSet = 
        new Guid(guidSimpleProjectCmdSetString);
    public static readonly Guid guidSimpleProjectFactory =  
        new Guid(guidSimpleProjectFactoryString);
};

  4. Speichern Sie die Datei, und schließen Sie den Editor.

  5. In Projektmappen-ExplorerSimpleProject mit der rechten Maustaste auf den Projektknoten, zeigen Sie auf Hinzufügen, und klicken Sie dann auf Neues Element. Fügen Sie KlasseSimpleProjectFactory.cshinzu. Klicken Sie auf Hinzufügen , um den Code-Editor zu öffnen.

  6. Fügen Sie das folgende using-Anweisung nach dem anderen using-Anweisungen hinzu.

    using System.Runtime.InteropServices;

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

    [Guid(GuidList.guidSimpleProjectFactoryString)]
class SimpleProjectFactory

  8. Erstellen Sie die Projektmappe, und überprüfen Sie, ob sie fehlerfrei erstellt.

Nun können Sie die Projektvorlage registrieren.

So zeigen Sie die Projektvorlage registrieren

  1. Öffnen Sie SimpleProjectPackage.cs im Code-Editor.

  2. Fügen Sie ein ProvideProjectFactoryAttribute-Attribut der SimpleProjectPackage-Klasse wie folgt hinzu.

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

  3. Erstellen Sie die Projektmappe, und überprüfen Sie, ob sie fehlerfrei erstellt.

    Das Neu erstellen registriert die Projektvorlage.

Das ProvideProjectFactory-Attribut hat die folgende Syntax.

public ProvideProjectFactoryAttribute(    Type factoryType,    string name,     string displayProjectFileExtensionsResourceID,    string defaultProjectExtension,    string possibleProjectExtensions,    string projectTemplatesDirectory)

Die Parameter defaultProjectExtension und possibleProjectExtensions werden zur Projekt (dateinamenerweiterung .myproj) festgelegt. Der projectTemplatesDirectory-Parameter wird auf den relativen Pfad des Vorlagenordners festgelegt. Während des Buildvorgangs wird dieser Pfad zu einer vollständigen Build konvertiert und in die Registrierung hinzugefügt, um das Projektsystem zu registrieren.

Untersuchen der Vorlagen-Registrierung

Während des Buildvorgangs erstellt Visual Studio eine Datei mit dem Namen SimpleProject.pkgdef, die die Informationen enthält, die benötigt werden, um die Vorlage zu verwenden. Dies ist eine versteckte Datei im Verzeichnis \ Bin \ Debug des Projekts Ordner. Öffnen Sie die Datei, um sicherzustellen, dass der Inhalt wie folgt lauten:

[$RootKey$\InstalledProducts\SimpleProjectPackage]
@="#110"
"Package"="{f202a1d5-9bf7-424c-a261-d7d2ab364560}"
"PID"="1.0"
"ProductDetails"="#112"
"LogoID"="#400"
[$RootKey$\Packages\{f202a1d5-9bf7-424c-a261-d7d2ab364560}]
@="Company.SimpleProject.SimpleProjectPackage, SimpleProject, Version=1.0.0.0, Culture=neutral, PublicKeyToken=cf624da7ef057ca0"
"InprocServer32"="$WinDir$\SYSTEM32\MSCOREE.DLL"
"Class"="Company.SimpleProject.SimpleProjectPackage"
"CodeBase"="$PackageFolder$\SimpleProject.dll"
[$RootKey$\Menus]
"{f202a1d5-9bf7-424c-a261-d7d2ab364560}"=", Menus.ctmenu, 1"
[$RootKey$\Projects\{471ec4bb-e47e-4229-a789-d1f5f83b52d4}]
@="SimpleProjectFactory"
"DisplayName"="Simple Project"
"DisplayProjectFileExtensions"="Simple Project Files (*.myproj);*.myproj"
"Package"="{f202a1d5-9bf7-424c-a261-d7d2ab364560}"
"DefaultProjectExtension"="myproj"
"PossibleProjectExtensions"="myproj"
"ProjectTemplatesDir"="$PackageFolder$\Templates\Projects\SimpleProject"
"Language(VsTemplate)"="SimpleProject"
[$RootKey$\NewProjectTemplates\TemplateDirs\{f202a1d5-9bf7-424c-a261-d7d2ab364560}\/1]
@="Simple Project"
"SortPriority"=dword:00000064
"TemplatesDir"="$PackageFolder$\Templates\Projects\SimpleProject"

Beachten Sie, dass die GUID in der Datei unterscheidet. Es stimmen die GUID in Guids.cs für das Projekt ab.

Die Vorlagen-Registrierung testen

Vorlagen Registration weist Visual Studio den Speicherort des Ordners mit Projektvorlagen für Visual Studio den Vorlagennamen und - Symbol im Neues Projekt Dialogfeld anzeigen kann.

So testen Sie die Registrierung der Vorlagen

  1. In Visual Studio Drücken Sie F5, um einer experimentellen Instanz von Visual Studio zu starten.

  2. Zeigen Sie im Menü Datei klicken Sie auf Neu, und klicken Sie dann auf Projekt. Wählen Sie im Dialogfeld Neues Projekt den SimpleProject-Projekttyp aus.

    Das SimpleProject-Symbol wird unter Von Visual Studio installierte Vorlagen.

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

Sie haben nun ein Projekt factory die Registrierung werden kann. Allerdings kann sie noch kein Projekt erstellen. Das Projekt Paket und factory Projekt, um ein Projekt zu erstellen und initialisieren.

Die Projekt-Factory initialisieren

Um die Verbindung zwischen dem Projekt und dem Projekt factory Paket zu implementieren, schließen Sie diese Aufgaben aus:

  • Zur Lösung fügen Sie Links Quellcodedateien für das Microsoft.VisualStudio.Package Seiten Projekt hinzu. Dieses Framework ist eine Erweiterung des verwalteten Paketframeworks (MPF). Das Projekt wird nur für Seiten als Quellcode bereitgestellt.

  • Leiten Sie SimpleProjectPackage von Microsoft.VisualStudio.Package.ProjectPackage ab.

  • Erstellen Sie SimpleProjectFactory , und registrieren Sie ihn mit Visual Studio, indem Sie die Microsoft.VisualStudio.Package.RegisterProjectFactory-Methode verwenden.

  • Leiten Sie SimpleProjectPackage von Microsoft.VisualStudio.Package.ProjectPackage ab.

  • Führen Sie zum SimpleProjectFactory-Konstruktor einen Verweis auf SimpleProjectPackage. Dieser Verweis wird für einen Dienstanbieter Site höher festlegen zwischengespeichert. Weitere Informationen zu Diensten finden Sie unter Dienste.

Um die Projekt initialisiert factory

  1. In Projektmappen-ExplorerSimpleProject mit der rechten Maustaste auf den Knoten, und klicken Sie dann auf Projekt entladen.

  2. SimpleProject der rechten Maustaste auf den Knoten, und klicken Sie anschließend auf SimpleProject.csproj bearbeiten.

  3. Suchen Sie die verwaltete Projektquelldateien, indem Sie befolgen this link. Kopieren Sie diese Dateien zu einem lokalen Ordner namens z. B. C:\MyLocalFolder\Project

  4. Im XML-Editor fügen Sie das folgende ProjectBasePath-Element nach dem RegisterWithCodebase-Element hinzu. Unterteilen Sie nicht die Zeile mit dem ProjectBasePath-Element enthält.

    <RegisterWithCodebase>true</RegisterWithCodebase>
<ProjectBasePath>C:\MyLocalFolder\Project</ProjectBasePath>

  5. Fügen Sie das folgende Import-Element nach den vorhandenen Import-Elementen hinzu.

    <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
<Import Project="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v10.0\VSSDK\Microsoft.VsSDK.targets" />
<Import Project="$(ProjectBasePath)\ProjectBase.Files" />

  6. Speichern Sie die Projektdatei, und schließen Sie den Editor.

  7. SimpleProject der rechten Maustaste auf den Knoten, und klicken Sie anschließend auf Projekt erneut laden.Projektmappen-Explorer sollte einen ProjectBase Ordner jetzt anzeigen.

  8. Klicken Sie mit der rechten Maustaste auf Verweise Knoten hinzu und fügen die folgenden .NET-Verweise.

    • EnvDTE (Visual Studio-Installations Pfad\ Common7 \ IDE \ PublicAssemblies \ EnvDTE.dll)

    • Microsoft.VisualStudio.Designer.Interfaces

  9. In der SimpleProjectPackage.cs-Datei fügen Sie die folgende using-Anweisung nach den vorhandenen using-Anweisungen hinzu.

    using Microsoft.VisualStudio.Package;

  10. Leiten Sie die Klasse von SimpleProjectPackageMicrosoft.VisualStudio.Package.ProjectPackage.

    public sealed class SimpleProjectPackage : ProjectPackage

  11. Fügen Sie die folgende Zeile der SimpleProjectPackage.Initialize-Methode direkt nach base.Initializehinzu.

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

  12. In SimpleProjectFactory.cs fügen Sie die folgende using-Anweisung nach den vorhandenen using-Anweisungen hinzu.

    using Microsoft.VisualStudio.Package;

  13. Leiten Sie die Klasse von SimpleProjectFactoryProjectFactory.

    class SimpleProjectFactory : ProjectFactory

  14. Fügen Sie die folgende blinde Methode der SimpleProjectFactory-Klasse hinzu. Implementieren Sie diese Methode in einem späteren Abschnitt.

    protected override ProjectNode CreateProject() 
{ 
    return null; 
}

  15. Fügen Sie das nächste Feld oder den Konstruktor der SimpleProjectFactory-Klasse hinzu. Dieser SimpleProjectPackage Verweis wird in einem privaten Feld gespeichert, damit er verwendet werden kann, wenn eine Website Dienstanbieter festgelegt wird.

    private SimpleProjectPackage package; 

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

  16. Erstellen Sie die Projektmappe, und überprüfen Sie, ob sie fehlerfrei erstellt.

Die Projekt-Factory-Implementierung testen

Überprüft, ob der Konstruktor für das Projekt factory Implementierung aufgerufen wird.

So testen Sie die Implementierung der factory

  1. In der SimpleProjectFactory.cs-Datei legen Sie einen Haltepunkt in der nächsten Zeile im SimpleProjectFactory-Konstruktor fest.

    this.package = package;

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

  3. Zeigen Sie im Menü Datei auf Neu, und klicken Sie dann auf Projekt.

  4. Wählen Sie im Dialogfeld Neues Projekt den SimpleProject-Projekttyp aus, und klicken Sie dann auf OK. Die Ausführung hält am Haltepunkt an.

  5. Löschen Sie den Haltepunkt.

  6. Drücken Sie UMSCHALT+F5 Debugvorgang beenden möchten.

Die Projektknoten-Klasse erweitern

Nun können Sie die SimpleProjectNode-Klasse implementieren, die von der ProjectNode-Klasse abgeleitet ist. Die ProjectNode Basisklasse behandelt die folgenden Aufgaben der Projekterstellung angezeigt:

  • Kopiert die Projektvorlagen, SimpleProject.myproj, der der neuen Datei im Projektordner. Die Kopie wird gemäß dem Namen umbenannt, der im Dialogfeld Neues Projekt eingegeben wurde. Der Eigenschaftswert wird ProjectGuid GUID durch ein neues ersetzt.

  • Durchläuft die MSBuild-Elemente der Projektvorlagen Datei, SimpleProject.myproj und sucht nach Compile-Elementen. Für jede Compile Zieldatei Kopien der Datei zum neuen Projektordner.

Die abgeleitete SimpleProjectNode-Klasse behandelt die folgenden Aufgaben:

  • Aktiviert Symbole für Projekt- und Dateiknoten in Projektmappen-Explorer erstellt oder ausgewählt wurde.

  • Aktiviert die zusätzlichen Ersetzen von Parametern Projektvorlagen angegeben werden.

Um die Projektknoten - Klasse erweitern

  1. Klicken Sie mit der rechten Maustaste auf den Projektknoten, zeigen Sie auf HinzufügenSimpleProject und klicken Sie dann auf Neues Element. Fügen Sie KlasseSimpleProjectNode.cshinzu. Klicken Sie auf Hinzufügen , um den Code-Editor zu öffnen.

  2. Ersetzen Sie den vorhandenen Code durch den folgenden Code.

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

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

        public SimpleProjectNode(SimpleProjectPackage package)
        {
            this.package = package;
        }
        public override Guid ProjectGuid
        {
            get { return GuidList.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 hat diese überschriebenen Methoden:

  • factory Projekt, das dieProjectGuidGUID zurückgibt.

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

  • AddFileFromTemplate, wählen Sie Dateien aus dem Ordner Vorlagen in das Zielprojekt kopiert. Diese Methode wird weiter in einem späteren Abschnitt implementiert.

Der SimpleProjectNode-Konstruktor, wie der SimpleProjectFactory-Konstruktors speichert einen SimpleProjectPackage Verweis auf ein privates Feld für die spätere Verwendung.

Um die SimpleProjectFactory-Klasse an die SimpleProjectNode-Klasse herzustellen, müssen Sie ein neues SimpleProjectNode in der SimpleProjectFactory.CreateProject-Methode instanziieren und sie in einem privaten Feld zur späteren Verwendung zwischenspeichern.

Um die Factoryklasse Projekt herstellen und die Knotenklasse

  1. In der SimpleProjectFactory.cs-Datei fügen Sie die folgende using-Anweisung nach den vorhandenen using-Anweisungen 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 Projektmappe, und überprüfen Sie, ob sie fehlerfrei erstellt.

Die Projektknoten-Klasse testen

Testen Sie das Projekt factory, um festzustellen, ob sie eine Projekthierarchie erstellt.

So testen Sie den Projektknoten class

  1. Drücken Sie F5, um einer experimentellen Instanz von Visual Studio zu starten.

  2. Zeigen Sie im Menü Datei auf Neu, und klicken Sie dann auf Projekt.

  3. Klicken Sie im Dialogfeld Neues Projekt unter Von Visual Studio installierte Vorlagen, wählen Sie SimpleProject.

  4. Wählen Sie im MyProject-Typ und Projektmappenverzeichnis erstellenName Feld.

  5. Geben Sie einen Speicherort für die Projektmappe für das Beispiel D:\ein.

  6. Klicken Sie auf OK.

    Visual Studio sollte das Projekt factory aufrufen, um ein Projekt zu erstellen.

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

Hinzufügen eines benutzerdefinierten Projektknoten-Symbol

Das Symbol Mein Projekt im vorherigen Abschnitt enthält ein Standardsymbol. Sie können sie an ein benutzerdefiniertes Symbol ändern.

So erstellen Sie ein benutzerdefiniertes Symbol Mein Projekt hinzufügen

  1. Klicken Sie mit der rechten Maustaste auf Ressourcen Ordner, zeigen Sie auf Hinzufügen, und klicken Sie dann auf Neues Element. Fügen Sie Bitmapdatei SimpleProjectNode.bmp hinzu. Klicken Sie auf Hinzufügen der Bitmap-Editor zu öffnen.

  2. In den Eigenschaften Fenstern verringern Sie die Bitmap bis 16 16 Pixel. Führen Sie die Bitmap unterscheidend.

    Einfaches Projekt - Comm

  3. Ändern Sie im Fenster EigenschaftenBuildvorgang der Bitmap in Eingebettete Ressource.

  4. In SimpleProjectNode.cs fügen Sie die folgenden Anweisungen using nach den vorhandenen using-Anweisungen hinzu.

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

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

    private static ImageList imageList; 

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

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

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

  7. Ersetzen Sie den Konstruktor für Instanzen, indem Sie den folgenden Code verwenden.

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

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

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

Während des statischen Konstruktion ruft die SimpleProjectNode bitmap Projektknoten aus dem Assemblymanifest Ressourcen ab und speichert sie in einem privaten Feld für die spätere Verwendung. Beachten Sie die Syntax des Assembly.GetManifestResourceStream Bilds Speicherpfad. Um die Namen der Ressourcen zu Manifesten finden, die in einer Assembly eingebettet sind, verwenden Sie die Assembly.GetManifestResourceNames-Methode. Wenn diese Methode SimpleProject Assembly angewendet wird, sind die Ergebnisse wie folgt lauten:

  • Company.SimpleProject.Resources.resources

  • Microsoft.VisualStudio.Package.Project.resources

  • Company.SimpleProject.VSPackage.resources

  • Resources.imagelis.bmp

  • Microsoft.VisualStudio.Package.DontShowAgainDialog.resources

  • Microsoft.VisualStudio.Package.SecurityWarningDialog.resources

  • Company.SimpleProject.Resources.SimpleProjectNode.bmp

Während der Instanz baus lädt die ProjectNode Basisklasse Resources.imagelis.bmp, wobei werden häufig verwendete 16 x 16 \ imagelis.bmp Erstellen von Ressourcen eingebettet. Diese Bitmap wird SimpleProjectNode als Liste verfügbar gemacht ImageHandler.ImageList. SimpleProjectNode fügt den Projektknoten bitmap der Liste an. Der Offset der Projektknoten bitmaps in der Bildliste wird für die spätere Verwendung als Wert der öffentlichen Eigenschaft ImageIndex zwischengespeichert. Visual Studio verwendet diese Eigenschaft, um zu bestimmen, welche erstellen, das als Symbol Mein Projekt anzuzeigen.

Testen des benutzerdefinierten Projektknoten-Symbol

Testen Sie das Projekt factory, um festzustellen, ob sie eine Projekthierarchie erstellt, die das benutzerdefinierte Symbol Mein Projekt.

So testen Sie das benutzerdefinierte Symbol Mein Projekt

  1. Löschen Sie die MyProject-Projektmappe.

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

  3. Zeigen Sie im Menü Datei auf Neu, und klicken Sie dann auf Projekt.

  4. Klicken Sie im Dialogfeld Neues Projekt unter Von Visual Studio installierte Vorlagen, wählen Sie SimpleProject.

  5. Wählen Sie im MyProject-Typ und Projektmappenverzeichnis erstellenName Feld.

  6. Geben Sie einen Speicherort für die Projektmappe für das Beispiel D:\ein.

  7. Klicken Sie auf OK.

    Visual Studio sollte ein Projekt erstellen. Beachten Sie, dass SimpleProjectNode.bmp als das Symbol Mein Projekt verwendet wird.

    Einfaches Projekt - Knoten Neues Projekt

  8. Öffnen Sie Program.cs im Code-Editor. Sie sollten den Quellcode finden, der folgendem 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 nicht $className$ neue Werte aufweisen. Sie können die Vorlagenparameter im nächsten Abschnitt implementieren.

  9. Drücken Sie UMSCHALT+F5 Debugvorgang beenden möchten.

Vorlagenparameter ersetzen

In einem vorhergehenden Abschnitt registrierten Sie die Projektvorlage in Visual Studio, indem Sie das ProvideProjectFactory-Attributs. Das Registrieren des Pfads eines Ordners Vorlagen können Sie auf diese Weise grundlegenden Vorlagenparameter Ersetzung aktivieren, indem Sie die ProjectNode.AddFileFromTemplate-Klasse überschrieben und erweitert. Weitere Informationen finden Sie unter Neue Projekt-Generierung: Bei der Haube zwei Komponenten.

Um die Werte von Vorlagenparametern $nameSpace$ und $className$ Vorlage in der Datei Program.cs zu ersetzen, müssen Sie Code zur AddFileFromTemplate-Klasse hinzufügen.

So Vorlagenparameter ersetzen

  1. In der SimpleProjectPackage.cs-Datei fügen Sie die folgende using-Anweisung nach den vorhandenen using-Anweisungen 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 nach der className Zuweisungsanweisung fest.

Mit Zuweisungsanweisungen bestimmen angemessene Werte für einen Namespace und einen neuen Klassennamen. Die beiden ProjectNode.FileTemplateProcessor.AddReplace ruft die entsprechenden Vorlagenparameter ersetzen, indem Sie diese Werte verwenden.

Testen des Vorlagenparameter-Ersatz

Testen Sie das Projekt factory, um festzustellen, ob sie eine Projekthierarchie mit dem benutzerdefinierten Symbol Mein Projekt erstellt.

So testen Sie die Vorlagenparameter

  1. Löschen Sie die MyProject-Projektmappe.

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

  3. Zeigen Sie im Menü Datei auf Neu, und klicken Sie dann auf Projekt.

  4. Klicken Sie im Dialogfeld Neues Projekt unter Von Visual Studio installierte Vorlagen, wählen Sie SimpleProject.

  5. Wählen Sie im MyProject-Typ und Projektmappenverzeichnis erstellenName Feld.

  6. Geben Sie einen Speicherort für die Projektmappe für das Beispiel D:\ein.

  7. Klicken Sie auf OK.

    Die Ausführung hält am Haltepunkt in der AddFileFromTemplate-Methode an.

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

    • nameSpace ist der Wert des <RootNamespace> Elements in der Master- \ \. \ SimpleProject- Projekte \ Templates SimpleProject.myproj Datei angegeben. In diesem Fall lautet der Wert „MyRootNamespace“.

    • className ist der Wert des quell der Klassen ohne die Dateinamenerweiterung angegeben. In diesem Fall ist die erste in den Zielordner kopiert werden sollen, Datei AssemblyInfo.cs; deshalb ist der Wert des Klassennamens „AssemblyInfo“.

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

    Visual Studio sollte ein Projekt erstellen, beenden.

  10. Öffnen Sie Program.cs im Code-Editor. Sie sollten den Quellcode finden, der folgendem 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 jetzt im Namespace „MyRootNamespace“ ist und der Klassenname jetzt „Programm“ ist.

  11. Drücken Sie in der experimentellen Instanz von Visual Studio die Taste F5. Das neue Projekt sollte „Hello, VSX kompilieren und ausführen“!!! anzeigen im Konsolenfenster.

    Befehl Einfaches Projekt

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

Siehe auch

Konzepte

Innerhalb von Visual Studio SDK

Weitere Ressourcen

Exemplarische Vorgehensweisen zum Anpassen von Visual Studio mithilfe von VSPackages

VSPackage-einbrennen