Tworzenie podstawowego systemu projektu, część 1

Artykuł
11/15/2023

W programie Visual Studio projekty to kontenery używane przez deweloperów do organizowania plików kodu źródłowego i innych zasobów. Projekty są wyświetlane jako elementy podrzędne rozwiązań w Eksplorator rozwiązań. Projekty umożliwiają organizowanie, kompilowanie, debugowanie i wdrażanie kodu źródłowego oraz tworzenie odwołań do usług sieci Web, baz danych i innych zasobów.

Projekty są definiowane w plikach projektu, na przykład plik csproj dla projektu Visual C#. Możesz utworzyć własny typ projektu, który ma własne rozszerzenie nazwy pliku projektu. Aby uzyskać więcej informacji na temat typów projektów, zobacz Project types (Typy projektów).

Uwaga

Jeśli musisz rozszerzyć program Visual Studio przy użyciu niestandardowego typu projektu, zdecydowanie zalecamy skorzystanie z systemu projektu Visual Studio (VSPS), który ma wiele zalet związanych z tworzeniem systemu projektu od podstaw:

Łatwiejsze dołączanie. Nawet podstawowy system projektu wymaga dziesiątek tysięcy wierszy kodu. Wykorzystanie usługi VSPS zmniejsza koszt dołączania do kilku kliknięć, zanim wszystko będzie gotowe do dostosowania go do własnych potrzeb.
Łatwiejsza konserwacja. Korzystając z usługi VSPS, wystarczy zachować własne scenariusze. Obsługujemy utrzymanie całej infrastruktury systemu projektu.

Jeśli potrzebujesz docelowych wersji programu Visual Studio starszych niż Visual Studio 2013, nie będzie można korzystać z usługi VSPS w rozszerzeniu programu Visual Studio. Jeśli tak jest, ten przewodnik jest dobrym miejscem do rozpoczęcia pracy.

W tym przewodniku pokazano, jak utworzyć typ projektu z rozszerzeniem nazwy pliku projektu .myproj. Ten przewodnik umożliwia wypożyczenie z istniejącego systemu projektu Visual C#.

Uwaga

Aby uzyskać więcej przykładów projektów rozszerzeń, zobacz przykłady zestawu VSSDK.

W tym przewodniku przedstawiono sposób wykonywania tych zadań:

Utwórz podstawowy typ projektu.
Utwórz podstawowy szablon projektu.
Zarejestruj szablon projektu w programie Visual Studio.
Utwórz wystąpienie projektu, otwierając okno dialogowe Nowy projekt , a następnie używając szablonu.
Utwórz fabrykę projektów dla systemu projektu.
Utwórz węzeł projektu dla systemu projektu.
Dodaj ikony niestandardowe dla systemu projektu.
Zaimplementuj podstawianie parametrów szablonu podstawowego.

Wymagania wstępne

Pobierz kod źródłowy programu Managed Package Framework dla projektów. Wyodrębnij plik do lokalizacji dostępnej dla rozwiązania, które chcesz utworzyć.

Tworzenie podstawowego typu projektu

Utwórz projekt VSIX języka C# o nazwie SimpleProject. (Utwórz>nowy>projekt, a następnie program Visual C#>Extensibility>VSIX Project). Dodaj szablon elementu projektu pakietu programu Visual Studio (na Eksplorator rozwiązań kliknij prawym przyciskiem myszy węzeł projektu i wybierz polecenie Dodaj>nowy element, a następnie przejdź do pozycji Rozszerzalność>pakietu Visual Studio). Nadaj plikowi nazwę SimpleProjectPackage.

Tworzenie podstawowego szablonu projektu

Teraz możesz zmodyfikować ten podstawowy pakiet VSPackage, aby zaimplementować nowy typ projektu myproj . Aby utworzyć projekt oparty na typie projektu myproj , program Visual Studio musi wiedzieć, które pliki, zasoby i odwołania mają zostać dodane do nowego projektu. Aby podać te informacje, umieść pliki projektu w folderze szablonu projektu. Gdy użytkownik używa projektu myproj do utworzenia projektu, pliki są kopiowane do nowego projektu.

Aby utworzyć podstawowy szablon projektu

Dodaj trzy foldery do projektu, jeden w drugim: Templates\Projects\SimpleProject. (W Eksplorator rozwiązań kliknij prawym przyciskiem myszy węzeł projektu SimpleProject, wskaż polecenie Dodaj, a następnie kliknij pozycję Nowy folder. Nadaj folderowi nazwę Szablony. W folderze Templates (Szablony) dodaj folder o nazwie Projects (Projekty). W folderze Projects dodaj folder o nazwie SimpleProject.
W folderze Templates\Projects\SimpleProject dodaj plik obrazu mapy bitowej do użycia jako ikonę o nazwie SimpleProject.ico. Po kliknięciu przycisku Dodaj zostanie otwarty edytor ikon.
Ustaw ikonę na charakterystyczną. Ta ikona zostanie wyświetlona w oknie dialogowym Nowy projekt w dalszej części przewodnika.
Zapisz ikonę i zamknij edytor ikon.
W folderze Templates\Projects\SimpleProject dodaj element Klasy o nazwie Program.cs.
Zastąp istniejący kod następującymi wierszami.
```
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();
        }
    }
}
```
Ważne

Nie jest to ostateczna forma kodu Program.cs . Parametry zastępcze będą traktowane w późniejszym kroku. Mogą pojawić się błędy kompilacji, ale o ile plik BuildAction to Zawartość, powinno być możliwe skompilowanie i uruchomienie projektu w zwykły sposób.
Zapisz plik.
Skopiuj plik AssemblyInfo.cs z folderu Properties do folderu Projects\SimpleProject.
W folderze Projects\SimpleProject dodaj plik XML o nazwie SimpleProject.myproj.

Uwaga

Rozszerzenie nazwy pliku dla wszystkich projektów tego typu to .myproj. Jeśli chcesz ją zmienić, musisz zmienić ją wszędzie tam, gdzie jest wymieniona w przewodniku.

Zastąp istniejącą zawartość następującymi wierszami.

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

Zapisz plik.
W oknie Właściwości ustaw właściwość Build Action of AssemblyInfo.cs, Program.cs, SimpleProject.ico i SimpleProject.myproj na Wartość Content, a następnie ustaw dla właściwości Include in VSIX wartość True.

W tym szablonie projektu opisano podstawowy projekt języka Visual C#, który ma zarówno konfigurację debugowania, jak i konfigurację wydania. Projekt zawiera dwa pliki źródłowe, AssemblyInfo.cs i Program.cs oraz kilka odwołań do zestawów. Po utworzeniu projektu na podstawie szablonu wartość ProjectGuid jest automatycznie zastępowana przez nowy identyfikator GUID.

W Eksplorator rozwiązań rozwinięty folder Szablony powinien wyglądać następująco:

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

Tworzenie podstawowej fabryki projektów

Musisz poinformować program Visual Studio o lokalizacji folderu szablonu projektu. W tym celu dodaj atrybut do klasy VSPackage, która implementuje fabrykę projektu, aby lokalizacja szablonu została zapisana w rejestrze systemowym podczas kompilowania pakietu VSPackage. Zacznij od utworzenia podstawowej fabryki projektu, która jest identyfikowana przez identyfikator GUID fabryki projektu. Użyj atrybutu , ProvideProjectFactoryAttribute aby połączyć fabrykę projektu z klasą SimpleProjectPackage .

Aby utworzyć podstawową fabrykę projektów

Utwórz identyfikatory GUID dla fabryki projektu (w menu Narzędzia kliknij pozycję Utwórz identyfikator GUID) lub użyj identyfikatora GUID w poniższym przykładzie. Dodaj identyfikatory GUID do SimpleProjectPackage klasy w pobliżu sekcji z już zdefiniowanym PackageGuidStringidentyfikatorem . Identyfikatory GUID muszą znajdować się zarówno w postaci identyfikatora GUID, jak i w postaci ciągu. Wynikowy kod powinien przypominać poniższy przykład.
```
    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);
    }
```
Dodaj klasę do najwyższego folderu SimpleProject o nazwie SimpleProjectFactory.cs.

Dodaj następujące dyrektywy using:

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

Dodaj atrybut GUID do SimpleProjectFactory klasy. Wartość atrybutu to nowy identyfikator GUID fabryki projektu.
```
[Guid(SimpleProjectPackage.SimpleProjectFactoryString)]
class SimpleProjectFactory
{
}
```
Teraz możesz zarejestrować szablon projektu.

Aby zarejestrować szablon projektu

W pliku SimpleProjectPackage.cs dodaj ProvideProjectFactoryAttribute atrybut do SimpleProjectPackage klasy w następujący sposób.

[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

Skompiluj rozwiązanie i sprawdź, czy kompiluje się bez błędów.

Ponowne kompilowanie rejestruje szablon projektu.

Parametry defaultProjectExtension i possibleProjectExtensions są ustawione na rozszerzenie nazwy pliku projektu (.myproj). Parametr projectTemplatesDirectory jest ustawiony na ścieżkę względną folderu Templates . Podczas kompilacji ta ścieżka zostanie przekonwertowana na pełną kompilację i dodana do rejestru w celu zarejestrowania systemu projektu.

Testowanie rejestracji szablonu

Rejestracja szablonu informuje program Visual Studio o lokalizacji folderu szablonu projektu, aby program Visual Studio mógł wyświetlić nazwę szablonu i ikonę w oknie dialogowym Nowy projekt .

Aby przetestować rejestrację szablonu

Naciśnij klawisz F5 , aby rozpocząć debugowanie eksperymentalnego wystąpienia programu Visual Studio.
W wystąpieniu eksperymentalnym utwórz nowy projekt nowo utworzonego typu projektu. W oknie dialogowym Nowy projekt w obszarze Zainstalowane szablony powinna być widoczna sekcja SimpleProject.

Teraz masz zarejestrowaną fabrykę projektów. Jednak nie może jeszcze utworzyć projektu. Pakiet projektu i fabryka projektów współpracują ze sobą w celu utworzenia i zainicjowania projektu.

Dodawanie kodu struktury pakietów zarządzanych

Zaimplementuj połączenie między pakietem projektu a fabryką projektu.

Zaimportuj pliki kodu źródłowego dla programu Managed Package Framework.
1. Zwolnij projekt SimpleProject (w Eksplorator rozwiązań wybierz węzeł projektu, a następnie w menu kontekstowym kliknij pozycję Zwolnij projekt) i otwórz plik projektu w edytorze XML.
2. Dodaj następujące bloki do pliku projektu (tuż nad <blokami importu> ). Ustaw ProjectBasePath wartość na lokalizację pliku ProjectBase.files w właśnie pobranym kodzie programu Managed Package Framework. Może być konieczne dodanie ukośnika odwrotnego do nazwy ścieżki. Jeśli tego nie zrobisz, projekt może nie znaleźć kodu źródłowego programu Managed Package Framework.
```
<PropertyGroup>
     <ProjectBasePath>your path here\</ProjectBasePath>
     <RegisterWithCodebase>true</RegisterWithCodebase>
  </PropertyGroup>
  <Import Project="$(ProjectBasePath)\ProjectBase.Files" />
```
  Ważne
  
  Nie zapomnij o ukośniku odwrotnym na końcu ścieżki.
3. Załaduj ponownie projekt.
4. Dodaj odwołania do następujących zestawów:
  - Microsoft.VisualStudio.Designer.Interfaces (w <VSSDK install>\VisualStudioIntegration\Common\Assemblies\v2.0)
  - WindowsBase
  - Microsoft.Build.Tasks.v4.0

Aby zainicjować fabrykę projektów

W pliku SimpleProjectPackage.cs dodaj następującą using dyrektywę.
```
using Microsoft.VisualStudio.Project;
```
Utwórz pochodną klasę SimpleProjectPackage z Microsoft.VisualStudio.Package.ProjectPackageklasy .
```
public sealed class SimpleProjectPackage : ProjectPackage
```
Zarejestruj fabrykę projektu. Dodaj następujący wiersz do SimpleProjectPackage.Initialize metody tuż po base.Initialize.
```
base.Initialize();
this.RegisterProjectFactory(new SimpleProjectFactory(this));
```

Zaimplementuj właściwość ProductUserContextabstrakcyjną :

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

W pliku SimpleProjectFactory.cs dodaj następującą using dyrektywę po istniejących dyrektywach using .
```
using Microsoft.VisualStudio.Project;
```
Utwórz pochodną klasę SimpleProjectFactory z ProjectFactoryklasy .
```
class SimpleProjectFactory : ProjectFactory
```
Dodaj następującą fikcyjną metodę do SimpleProjectFactory klasy . Ta metoda zostanie zaimplementowana w późniejszej sekcji.
```
protected override ProjectNode CreateProject()
{
    return null;
}
```
Dodaj następujące pole i konstruktor do SimpleProjectFactory klasy . To SimpleProjectPackage odwołanie jest buforowane w polu prywatnym, aby można było go użyć w ustawieniu lokacji dostawcy usług.
```
private SimpleProjectPackage package;

public SimpleProjectFactory(SimpleProjectPackage package)
    : base(package)
{
    this.package = package;
}
```
Skompiluj rozwiązanie i sprawdź, czy kompiluje się bez błędów.

Testowanie implementacji fabryki projektu

Sprawdź, czy konstruktor implementacji fabryki projektu jest wywoływany.

Aby przetestować implementację fabryki projektu

W pliku SimpleProjectFactory.cs ustaw punkt przerwania w następującym wierszu w konstruktorzeSimpleProjectFactory.
```
this.package = package;
```
Naciśnij klawisz F5 , aby uruchomić eksperymentalne wystąpienie programu Visual Studio.
W wystąpieniu eksperymentalnym rozpocznij tworzenie nowego projektu. W oknie dialogowym Nowy projekt wybierz typ projektu SimpleProject, a następnie kliknij przycisk OK. Wykonanie zatrzymuje się w punkcie przerwania.
Wyczyść punkt przerwania i zatrzymaj debugowanie. Ponieważ nie utworzyliśmy jeszcze węzła projektu, kod tworzenia projektu nadal zgłasza wyjątki.

Rozszerzanie klasy ProjectNode

Teraz możesz zaimplementować klasę SimpleProjectNode , która pochodzi z ProjectNode klasy . Klasa podstawowa ProjectNode obsługuje następujące zadania tworzenia projektu:

Kopiuje plik szablonu projektu SimpleProject.myproj do nowego folderu projektu. Nazwa kopii jest zmieniana zgodnie z nazwą wprowadzoną w oknie dialogowym Nowy projekt . ProjectGuid Wartość właściwości jest zastępowana przez nowy identyfikator GUID.
Przechodzi przez elementy MSBuild pliku szablonu projektu SimpleProject.myproj i wyszukuje Compile elementy. Dla każdego Compile pliku docelowego kopiuje plik do nowego folderu projektu.

Klasa pochodna SimpleProjectNode obsługuje następujące zadania:
Włącza ikony dla węzłów projektu i plików w Eksplorator rozwiązań do utworzenia lub wybrania.
Umożliwia określenie dodatkowych podstawiania parametrów szablonu projektu.

Aby rozszerzyć klasę ProjectNode

Dodaj klasę o nazwie SimpleProjectNode.cs.

Zastąp istniejący kod następującym kodem.

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

Ta SimpleProjectNode implementacja klasy ma te zastąpione metody:

ProjectGuid, który zwraca identyfikator GUID fabryki projektu.
ProjectType, który zwraca zlokalizowaną nazwę typu projektu.
AddFileFromTemplate, który kopiuje wybrane pliki z folderu szablonu do projektu docelowego. Ta metoda jest dodatkowo zaimplementowana w dalszej sekcji.

Konstruktor SimpleProjectNode , podobnie jak SimpleProjectFactory konstruktor, buforuje SimpleProjectPackage odwołanie w polu prywatnym do późniejszego użycia.

Aby połączyć klasę SimpleProjectFactory z klasą SimpleProjectNode , należy utworzyć wystąpienie nowej SimpleProjectNode metody i SimpleProjectFactory.CreateProject zapisać ją w pamięci podręcznej w polu prywatnym do późniejszego użycia.

Aby połączyć klasę fabryki projektu i klasę węzła

W pliku SimpleProjectFactory.cs dodaj następującą using dyrektywę:

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

Zastąp metodę SimpleProjectFactory.CreateProject przy użyciu następującego kodu.

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

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

Skompiluj rozwiązanie i sprawdź, czy kompiluje się bez błędów.

Testowanie klasy ProjectNode

Przetestuj fabrykę projektu, aby sprawdzić, czy tworzy hierarchię projektu.

Aby przetestować klasę ProjectNode

Naciśnij klawisz F5, aby uruchomić debugowanie. W wystąpieniu eksperymentalnym utwórz nowy projekt SimpleProject.
Program Visual Studio powinien wywołać fabrykę projektu, aby utworzyć projekt.
Zamknij eksperymentalne wystąpienie programu Visual Studio.

Dodawanie niestandardowej ikony węzła projektu

Ikona węzła projektu we wcześniejszej sekcji jest ikoną domyślną. Możesz zmienić go na ikonę niestandardową.

Aby dodać niestandardową ikonę węzła projektu

W folderze Resources dodaj plik mapy bitowej o nazwie SimpleProjectNode.bmp.
W oknach Właściwości zmniejsz mapę bitową do 16 o 16 pikseli. Wyróżnij mapę bitową.
W oknie Właściwości zmień akcję Kompilacja mapy bitowej na Zasób osadzony.
W pliku SimpleProjectNode.cs dodaj następujące using dyrektywy:
```
using System.Drawing;
using System.Windows.Forms;
```

Dodaj następujące pole statyczne i konstruktor do SimpleProjectNode klasy .

private static ImageList imageList;

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

Dodaj następującą właściwość na początku SimpleProjectNode klasy.

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

Zastąp konstruktor wystąpienia następującym kodem.
```
public SimpleProjectNode(SimpleProjectPackage package)
{
    this.package = package;

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

    foreach (Image img in imageList.Images)
    {
        this.ImageHandler.AddImage(img);
    }
}
```
Podczas budowy SimpleProjectNode statycznej pobiera mapę bitową węzła projektu z zasobów manifestu zestawu i buforuje je w prywatnym polu do późniejszego użycia. Zwróć uwagę na składnię ścieżki GetManifestResourceStream obrazu. Aby wyświetlić nazwy zasobów manifestu osadzonych w zestawie, użyj GetManifestResourceNames metody . Po zastosowaniu SimpleProject tej metody do zestawu wyniki powinny być następujące:

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

Podczas budowy wystąpienia klasa bazowa ProjectNode ładuje bibliotekę Resources.imagelis.bmp, w której osadzono często używane 16 x 16 map bitowych z pliku Resources\imagelis.bmp. Ta lista map bitowych jest udostępniana SimpleProjectNode jako ImageHandler.ImageList. SimpleProjectNode Dołącza mapę bitową węzła projektu do listy. Przesunięcie mapy bitowej węzła projektu na liście obrazów jest buforowane do późniejszego użycia jako wartość właściwości publicznej ImageIndex . Program Visual Studio używa tej właściwości do określenia, która mapa bitowa ma być wyświetlana jako ikona węzła projektu.

Testowanie ikony niestandardowego węzła projektu

Przetestuj fabrykę projektów, aby sprawdzić, czy tworzy hierarchię projektu, która ma niestandardową ikonę węzła projektu.

Aby przetestować ikonę niestandardowego węzła projektu

Rozpocznij debugowanie i w wystąpieniu eksperymentalnym utwórz nowy projekt SimpleProject.
W nowo utworzonym projekcie zwróć uwagę, że plik SimpleProjectNode.bmp jest używany jako ikona węzła projektu.
Otwórz plik Program.cs w edytorze kodu. Powinien zostać wyświetlony kod źródłowy podobny do poniższego kodu.
```
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();
        }
    }
}
```
Zwróć uwagę, że parametry szablonu $nameSpace$ i $className$ nie mają nowych wartości. Dowiesz się, jak zaimplementować podstawianie parametrów szablonu w następnej sekcji.

Podstaw parametry szablonu

We wcześniejszej sekcji zarejestrowano szablon projektu w programie Visual Studio przy użyciu atrybutu ProvideProjectFactory . Zarejestrowanie ścieżki folderu szablonu w ten sposób umożliwia włączenie podstawiania parametrów szablonu przez zastąpienie i rozszerzenie ProjectNode.AddFileFromTemplate klasy. Aby uzyskać więcej informacji, zobacz New project generation: Under the hood (Nowa generacja projektu: pod maską, część druga).

Teraz dodaj kod zastępczy do AddFileFromTemplate klasy.

Aby zastąpić parametry szablonu

W pliku SimpleProjectNode.cs dodaj następującą using dyrektywę.
```
using System.IO;
```

Zastąp metodę AddFileFromTemplate przy użyciu następującego kodu.

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

Ustaw punkt przerwania w metodzie tuż po instrukcji className przypisania.

Instrukcje przypisania określają rozsądne wartości przestrzeni nazw i nową nazwę klasy. ProjectNode.FileTemplateProcessor.AddReplace Dwie metody zastępują odpowiednie wartości parametrów szablonu przy użyciu tych nowych wartości.

Testowanie podstawienia parametrów szablonu

Teraz możesz przetestować podstawienie parametrów szablonu.

Aby przetestować podstawienie parametrów szablonu

Rozpocznij debugowanie i w wystąpieniu eksperymentalnym utwórz nowy projekt SimpleProject.
Wykonanie zatrzymuje się w punkcie przerwania w metodzie AddFileFromTemplate .
Sprawdź wartości parametrów nameSpace i className .
- nameSpace parametr ma wartość <elementu RootNamespace> w pliku szablonu projektu \Templates\Projects\SimpleProject\SimpleProject.myproj . W tym przypadku wartość to MyRootNamespace.
- className parametr ma wartość nazwy pliku źródłowego klasy bez rozszerzenia nazwy pliku. W takim przypadku pierwszym plikiem do skopiowania do folderu docelowego jest AssemblyInfo.cs, dlatego wartość className to AssemblyInfo.
Usuń punkt przerwania i naciśnij klawisz F5 , aby kontynuować wykonywanie.

Program Visual Studio powinien zakończyć tworzenie projektu.

Otwórz plik Program.cs w edytorze kodu. Powinien zostać wyświetlony kod źródłowy podobny do poniższego kodu.

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

Zwróć uwagę, że przestrzeń nazw to teraz MyRootNamespace , a nazwa klasy to teraz Program.

Rozpocznij debugowanie projektu. Nowy projekt powinien zostać skompilowany, uruchomiony i wyświetlony komunikat "Hello VSX!!" w oknie konsoli.

Gratulacje! Zaimplementowano podstawowy zarządzany system projektów.

Udostępnij za pośrednictwem