Teilen über

Erstellen eines grundlegenden Projektsystems, Teil 2

  • Artikel

Die erste exemplarische Vorgehensweise in dieser Reihe, Erstellen eines einfachen Projektsystems, Teil 1, zeigt, wie Sie ein grundlegendes Projektsystem erstellen. Diese exemplarische Vorgehensweise baut auf dem grundlegenden Projektsystem auf, indem eine Visual Studio-Vorlage, eine Eigenschaftenseite und andere Features hinzugefügt werden. Sie müssen die erste exemplarische Vorgehensweise ausführen, bevor Sie mit dieser exemplarischen Vorgehensweise beginnen.

In dieser exemplarischen Vorgehensweise erfahren Sie, wie Sie einen Projekttyp erstellen, der die Projektdateierweiterung ".myproj" aufweist. Um die exemplarische Vorgehensweise abzuschließen, müssen Sie keine eigene Sprache erstellen, da sich die exemplarische Vorgehensweise aus dem vorhandenen Visual C#-Projektsystem bezieht.

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

  • Erstellen Sie eine Visual Studio-Vorlage.

  • Stellen Sie eine Visual Studio-Vorlage bereit.

  • Erstellen Eines untergeordneten Projekttypknotens im Dialogfeld "Neues Projekt ".

  • Aktivieren Sie die Parameterersetzung in der Visual Studio-Vorlage.

  • Erstellen Sie eine Projekteigenschaftsseite.

Hinweis

Die Schritte in dieser exemplarischen Vorgehensweise basieren auf einem C#-Projekt. Mit Ausnahme von Besonderheiten wie Dateinamenerweiterungen und Code können Sie jedoch dieselben Schritte für ein Visual Basic-Projekt ausführen.

Erstellen einer Visual Studio-Vorlage

Mithilfe einer Visual Studio-Vorlage (VSTEMPLATE-Datei ) anstelle einer einfachen Projektvorlage können Sie steuern, wie die Vorlage im Dialogfeld "Neues Projekt " angezeigt wird und wie Vorlagenparameter ersetzt werden. Eine VSTEMPLATE-Datei ist eine XML-Datei, die beschreibt, wie Quelldateien einbezogen werden sollen, wenn ein Projekt mithilfe der Projektsystemvorlage erstellt wird. Das Projektsystem selbst wird erstellt, indem die VSTEMPLATE-Datei und die Quelldateien in einer ZIP-Datei gesammelt und durch Kopieren der ZIP-Datei an einen Speicherort bereitgestellt werden, der visual Studio bekannt ist. Dieser Vorgang wird weiter unten in dieser exemplarischen Vorgehensweise ausführlicher erläutert.

  1. Öffnen Sie in Visual Studio die SimpleProject-Projektmappe, die Sie mithilfe von Create a basic project system, part 1 erstellt haben.

  2. Suchen Sie in der Datei "SimpleProjectPackage.cs " das Attribut "ProvideProjectFactory". Ersetzen Sie den zweiten Parameter (den Projektnamen) durch NULL, und den vierten Parameter (der Pfad zum Projektvorlagenordner) durch ".\\NullPath", wie folgt.

    [ProvideProjectFactory(typeof(SimpleProjectFactory), null,
    "Simple Project Files (*.myproj);*.myproj", "myproj", "myproj",
    ".\\NullPath",
LanguageVsTemplate = "SimpleProject")]

  3. Fügen Sie dem Ordner \Templates\Projects\SimpleProject\ eine XML-Datei mit dem Namen "SimpleProject.vstemplate" hinzu.

  4. Ersetzen Sie den Inhalt von SimpleProject.vstemplate durch den folgenden 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. Wählen Sie im Eigenschaftenfenster alle fünf Dateien im Ordner \Templates\Projects\SimpleProject\ aus, und legen Sie die Buildaktion auf ZipProject fest.

    Simple Project Folder

    Der <TemplateData-Abschnitt> bestimmt den Speicherort und die Darstellung des SimpleProject-Projekttyps im Dialogfeld "Neues Projekt " wie folgt:

  • Das Name-Element <> benennt die Projektvorlage als SimpleProject Application.

  • Das <Description-Element> enthält die Beschreibung, die im Dialogfeld "Neues Projekt " angezeigt wird, wenn die Projektvorlage ausgewählt ist.

  • Das <Icon-Element> gibt das Symbol an, das zusammen mit dem Projekttyp "SimpleProject" angezeigt wird.

  • Das ProjectType-Element <> benennt den Projekttyp im Dialogfeld "Neues Projekt". Dieser Name ersetzt den Projektnamenparameter des ProvideProjectFactory-Attributs.

    Hinweis

    Das <ProjectType-Element> muss mit dem LanguageVsTemplate Argument des ProvideProjectFactory Attributs in der Datei "SimpleProjectPackage.cs" übereinstimmen.

    Der <TemplateContent-Abschnitt> beschreibt diese Dateien, die generiert werden, wenn ein neues Projekt erstellt wird:

  • SimpleProject.myproj

  • Program.cs

  • Assemblyinfo.cs

    Alle drei Dateien sind ReplaceParameters auf "true" festgelegt, wodurch die Parameterersetzung ermöglicht wird. Die Datei "Program.cs " ist OpenInEditor auf "true" festgelegt, wodurch die Datei beim Erstellen eines Projekts im Code-Editor geöffnet wird.

    Weitere Informationen zu den Elementen im Visual Studio-Vorlagenschema finden Sie in der Visual Studio-Vorlagenschemareferenz.

Hinweis

Wenn ein Projekt mehrere Visual Studio-Vorlagen enthält, befindet sich jede Vorlage in einem separaten Ordner. Jede Datei in diesem Ordner muss die Buildaktion auf ZipProject festgelegt haben.

Hinzufügen einer minimalen VSCT-Datei

Visual Studio muss im Setupmodus ausgeführt werden, um eine neue oder geänderte Visual Studio-Vorlage zu erkennen. Für den Setupmodus muss eine VSCT-Datei vorhanden sein. Daher müssen Sie dem Projekt eine minimale VSCT-Datei hinzufügen.

  1. Fügen Sie dem SimpleProject-Projekt eine XML-Datei namens "SimpleProject.vsct " hinzu.

  2. Ersetzen Sie den Inhalt der Datei "SimpleProject.vsct " durch den folgenden Code.

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

  3. Legen Sie die Buildaktion dieser Datei auf VSCTCompile fest. Dies ist nur in der CSPROJ-Datei möglich, nicht im Eigenschaftenfenster . Stellen Sie sicher, dass die Buildaktion dieser Datei an diesem Punkt auf "Keine" festgelegt ist.

    1. Klicken Sie mit der rechten Maustaste auf den Knoten "SimpleProject", und klicken Sie dann auf "SimpleProject.csproj bearbeiten".

    2. Suchen Sie in der CSPROJ-Datei nach dem Element "SimpleProject.vsct ".

      <None Include="SimpleProject.vsct" />

    3. Ändern Sie die Buildaktion in VSCTCompile.

      <VSCTCompile Include="SimpleProject.vsct" />

    4. die Projektdatei, und schließen Sie den Editor.

    5. Speichern Sie den Knoten "SimpleProject", und klicken Sie dann im Projektmappen-Explorer auf "Projekt erneut laden".

Untersuchen der Erstellungsschritte für Visual Studio-Vorlagen

Das VSPackage-Projektbuildsystem führt Visual Studio in der Regel im Setupmodus aus, wenn die VSTEMPLATE-Datei geändert wird oder das Projekt, das die VSTEMPLATE-Datei enthält, neu erstellt wird. Sie können folgen, indem Sie die Ausführlichkeitsebene von MSBuild auf "Normal" oder höher festlegen.

  1. Klicken Sie im Menü Extras auf Optionen.

  2. Erweitern Sie den Knoten "Projekte und Lösungen ", und wählen Sie dann "Erstellen und Ausführen" aus.

  3. Legen Sie die Verbosität des MSBuild-Projekts auf "Normal" fest. Klicken Sie auf OK.

  4. Erstellen Sie das SimpleProject-Projekt neu.

    Der Buildschritt zum Erstellen der ZIP-Projektdatei sollte dem folgenden Beispiel ähneln.

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

Bereitstellen einer Visual Studio-Vorlage

Visual Studio-Vorlagen enthalten keine Pfadinformationen. Daher muss die ZIP-Datei der Vorlage an einem Speicherort bereitgestellt werden, der visual Studio bekannt ist. Der Speicherort des ProjectTemplates-Ordners ist in der Regel <%LOCALAPPDATA%>\Microsoft\VisualStudio\14.0Exp\ProjectTemplates.

Um Ihre Projektfactory bereitzustellen, muss das Installationsprogramm über Administratorrechte verfügen. Es stellt Vorlagen unter dem Visual Studio-Installationsknoten bereit: ...\Microsoft Visual Studio 14.0\Common7\IDE\ProjectTemplates.

Testen einer Visual Studio-Vorlage

Testen Sie Die Projektfactory, um zu sehen, ob eine Projekthierarchie mithilfe der Visual Studio-Vorlage erstellt wird.

  1. Setzen Sie die experimentelle Instanz des Visual Studio SDK zurück.

    Suchen Sie unter Windows 7: Suchen Sie im Startmenü den Ordner "Microsoft Visual Studio/Microsoft Visual Studio SDK/Tools", und wählen Sie dann "Microsoft Visual Studio Experimental"-Instanz zurücksetzen.

    Geben Sie in späteren Versionen von Windows: Geben Sie auf dem Startbildschirm die Microsoft Visual Studio-Version <> Experimentalinstanz zurück.

  2. Ein Eingabeaufforderungsfenster wird angezeigt. Wenn die Wörter angezeigt werden, drücken Sie eine beliebige Taste, um den Vorgang fortzusetzen, und klicken Sie auf DIE EINGABETASTE. Öffnen Sie Visual Studio, nachdem das Fenster geschlossen wurde.

  3. Erstellen Sie das SimpleProject-Projekt neu, und starten Sie das Debuggen. Die experimentelle Instanz wird geöffnet.

  4. Erstellen Sie in der experimentellen Instanz ein SimpleProject-Projekt. Wählen Sie im Dialogfeld "Neues Projekt" die Option "SimpleProject" aus.

  5. Es sollte eine neue Instanz von SimpleProject angezeigt werden.

    Simple Project New Instance

    My Project New Instance

Erstellen eines untergeordneten Projekttypknotens

Sie können einem Projekttypknoten im Dialogfeld "Neues Projekt " einen untergeordneten Knoten hinzufügen. For example, for the SimpleProject project type, you could have child nodes for console applications, window applications, web applications, and so on.

Untergeordnete Knoten werden durch Ändern der Projektdatei und Hinzufügen von <untergeordneten OutputSubPath-Elementen> zu den <ZipProject-Elementen> erstellt. Wenn eine Vorlage während des Builds oder der Bereitstellung kopiert wird, wird jeder untergeordnete Knoten zu einem Unterordner des Projektvorlagenordners.

In diesem Abschnitt wird gezeigt, wie Sie einen untergeordneten Konsolenknoten für den SimpleProject-Projekttyp erstellen.

  1. Benennen Sie den Ordner \Templates\Projects\SimpleProject\ in \Templates\Projects\ConsoleApp\ um.

  2. Wählen Sie im Eigenschaftenfenster alle fünf Dateien im Ordner \Templates\Projects\ConsoleApp\ aus, und stellen Sie sicher, dass die Buildaktion auf ZipProject festgelegt ist.

  3. Fügen Sie in der Datei "SimpleProject.vstemplate" die folgende Zeile am Ende des <TemplateData-Abschnitts> direkt vor dem schließenden Tag hinzu.

    <NumberOfParentCategoriesToRollUp>1</NumberOfParentCategoriesToRollUp>

    Dies bewirkt, dass die Konsolenanwendungsvorlage sowohl im untergeordneten Konsolenknoten als auch im übergeordneten Knoten "SimpleProject" angezeigt wird. Dies ist eine Ebene über dem untergeordneten Knoten.

  4. Speichern Sie die Datei "SimpleProject.vstemplate ".

  5. Fügen Sie in der CSPROJ-Datei "OutputSubPath>" zu den einzelnen ZipProject-Elementen hinzu<. Entladen Sie das Projekt wie zuvor, und bearbeiten Sie die Projektdatei.

  6. Suchen Sie die <ZipProject-Elemente> . Fügen Sie jedem <ZipProject-Element> ein <OutputSubPath-Element> hinzu, und weisen Sie ihm die Wertkonsole zu. The 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. Fügen Sie diese <PropertyGroup> zur Projektdatei hinzu:

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

  8. Speichern Sie die Projektdatei, und laden Sie das Projekt neu.

Testen des untergeordneten Knotens des Projekttyps

Testen Sie die geänderte Projektdatei, um festzustellen, ob der untergeordnete Knoten der Konsole im Dialogfeld "Neues Projekt " angezeigt wird.

  1. Führen Sie das Tool "Experimentelle Instanz von Microsoft Visual Studio zurücksetzen" aus.

  2. Erstellen Sie das SimpleProject-Projekt neu, und starten Sie das Debuggen. Die experimentelle Instanz sollte angezeigt werden.

  3. Klicken Sie im Dialogfeld "Neues Projekt " auf den Knoten "SimpleProject ". Die Vorlage "Konsolenanwendung " sollte im Vorlagenbereich angezeigt werden.

  4. Erweitern Sie den Knoten "SimpleProject ". Der untergeordnete Konsolenknoten sollte angezeigt werden. Die Vorlage "SimpleProject Application" wird weiterhin im Vorlagenbereich angezeigt.

  5. Klicken Sie auf "Abbrechen", und beenden Sie das Debuggen.

    Simple Project Rollup

    Simple Project Console Node

Ersetzen von Projektvorlagenparametern

  • Das Erstellen eines grundlegenden Projektsystems, Teil 1 , zeigte, wie die ProjectNode.AddFileFromTemplate Methode überschrieben wird, um eine grundlegende Art von Vorlagenparameterersetzung durchzuführen. In diesem Abschnitt erfahren Sie, wie Sie die komplexeren Visual Studio-Vorlagenparameter verwenden.

Wenn Sie ein Projekt mithilfe einer Visual Studio-Vorlage im Dialogfeld "Neues Projekt " erstellen, werden Vorlagenparameter durch Zeichenfolgen zum Anpassen des Projekts ersetzt. Ein Vorlagenparameter ist ein spezielles Token, das mit einem Dollarzeichen beginnt und endet, z. B. $time$. Die folgenden beiden Parameter sind besonders hilfreich für die Aktivierung von Anpassungen in Projekten, die auf der Vorlage basieren:

  • $GUID[1-10]$ wird durch eine neue GUID ersetzt. Sie können bis zu 10 eindeutige GUIDs angeben, z. B. $guid 1$.

  • $safeprojectname$ ist der Name, der von einem Benutzer im Dialogfeld "Neues Projekt " bereitgestellt wird, geändert, um alle unsicheren Zeichen und Leerzeichen zu entfernen.

    Eine vollständige Liste der Vorlagenparameter finden Sie unter Vorlagenparameter.

So ersetzen Sie Projektvorlagenparameter

  1. Entfernen Sie in der Datei "SimpleProjectNode.cs " die AddFileFromTemplate Methode.

  2. Suchen Sie in der Datei \Templates\Projects\ConsoleApp\SimpleProject.myproj die <RootNamespace-Eigenschaft> , und ändern Sie den Wert in $safeprojectname$.

    <RootNamespace>$safeprojectname$</RootNamespace>

  3. Ersetzen Sie in der Datei \Templates\Projects\SimpleProject\Program.cs den Inhalt der Datei durch den folgenden 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. Erstellen Sie das SimpleProject-Projekt neu, und starten Sie das Debuggen. Die experimentelle Instanz sollte angezeigt werden.

  5. Erstellen Sie eine neue SimpleProject-Konsolenanwendung. (Im Bereich "Projekttypen", wählen Sie "SimpleProject" aus. Wählen Sie unter installierten Vorlagen von Visual Studio die Option "Konsolenanwendung" aus.)

  6. Öffnen Sie im neu erstellten Projekt "Program.cs". Es sollte etwa wie folgt aussehen (GUID-Werte in Ihrer Datei unterscheiden sich.):

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

Erstellen einer Projekteigenschaftsseite

Sie können eine Eigenschaftenseite für Ihren Projekttyp erstellen, damit Benutzer Eigenschaften in Projekten anzeigen und ändern können, die auf Ihrer Vorlage basieren. In diesem Abschnitt wird gezeigt, wie Sie eine konfigurationsunabhängige Eigenschaftenseite erstellen. Diese grundlegende Eigenschaftenseite verwendet ein Eigenschaftenraster, um die öffentlichen Eigenschaften anzuzeigen, die Sie in Der Eigenschaftenseitenklasse verfügbar machen.

Leiten Sie die Eigenschaftenseitenklasse von der SettingsPage Basisklasse ab. Das von der Klasse bereitgestellte Eigenschaftenraster kennt die SettingsPage meisten primitiven Datentypen und weiß, wie sie angezeigt werden. Darüber hinaus weiß die SettingsPage Klasse, wie Eigenschaftswerte in der Projektdatei beibehalten werden.

Auf der Eigenschaftenseite, die Sie in diesem Abschnitt erstellen, können Sie diese Projekteigenschaften ändern und speichern:

  • AssemblyName

  • OutputType

  • Rootnamespace.

  1. Fügen Sie in der Datei "SimpleProjectPackage.cs " dieses ProvideObject Attribut der SimpleProjectPackage Klasse hinzu:

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

    Dadurch wird die Eigenschaftenseitenklasse GeneralPropertyPage bei COM registriert.

  2. Fügen Sie in der Datei "SimpleProjectNode.cs " der SimpleProjectNode Klasse die folgenden beiden überschriebenen Methoden hinzu:

    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 geben ein Array von Eigenschaftenseiten-GUIDs zurück. Die GeneralPropertyPage-GUID ist das einzige Element im Array, sodass im Dialogfeld "Eigenschaftenseiten " nur eine Seite angezeigt wird.

  3. Fügen Sie dem SimpleProject-Projekt eine Klassendatei namens "GeneralPropertyPage.cs " hinzu.

  4. Ersetzen Sie den Inhalt dieser Datei durch den folgenden 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;
        }
    }
}

    Die GeneralPropertyPage Klasse macht die drei öffentlichen Eigenschaften AssemblyName, OutputType und RootNamespace verfügbar. Da AssemblyName keine Set-Methode aufweist, wird sie als schreibgeschützte Eigenschaft angezeigt. OutputType ist eine aufgezählte Konstante, sodass sie als Dropdownliste angezeigt wird.

    Die SettingsPage Basisklasse stellt bereit ProjectMgr , um die Eigenschaften beizubehalten. Die BindProperties Methode verwendet ProjectMgr , um die dauerhaften Eigenschaftswerte abzurufen und die entsprechenden Eigenschaften festzulegen. Die ApplyChanges Methode verwendet ProjectMgr , um die Werte der Eigenschaften abzurufen und in der Projektdatei beizubehalten. Die Eigenschaftssatzmethode wird auf "true" festgelegt IsDirty , um anzugeben, dass die Eigenschaften beibehalten werden müssen. Persistenz tritt auf, wenn Sie das Projekt oder die Projektmappe speichern.

  5. Erstellen Sie die SimpleProject-Lösung neu, und starten Sie das Debuggen. Die experimentelle Instanz sollte angezeigt werden.

  6. Erstellen Sie in der experimentellen Instanz eine neue SimpleProject-Anwendung.

  7. Visual Studio ruft Ihre Projektfactory auf, um ein Projekt mithilfe der Visual Studio-Vorlage zu erstellen. Die neue Datei Program.cs wird im Code-Editor geöffnet.

  8. Klicken Sie mit der rechten Maustaste in Projektmappen-Explorer auf den Projektknoten, und klicken Sie dann auf Eigenschaften. Das Dialogfeld Eigenschaftenseiten wird angezeigt.

    Simple Project Property Page

Testen der Projekteigenschaftsseite

Jetzt können Sie testen, ob Sie Eigenschaftswerte ändern und ändern können.

  1. Ändern Sie im Dialogfeld "Eigenschaftenseiten von MyConsoleApplication" den Standardwert in "MyApplication".

  2. Wählen Sie die OutputType-Eigenschaft und dann "Klassenbibliothek" aus.

  3. Klicken Sie auf Übernehmen und anschließend auf OK.

  4. Öffnen Sie das Dialogfeld Eigenschaftenseiten erneut, und stellen Sie sicher, dass Ihre Änderungen beibehalten wurden.

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

  6. Öffnen Sie die experimentelle Instanz erneut.

  7. Öffnen Sie das Dialogfeld Eigenschaftenseiten erneut, und stellen Sie sicher, dass Ihre Änderungen beibehalten wurden.

  8. Schließen Sie die experimentelle Instanz von Visual Studio. Close the experimental instance