Tworzenie podstawowego systemu projektu, część 2

Artykuł
06/19/2023

Pierwszy przewodnik z tej serii Tworzenie podstawowego systemu projektu , część 1, pokazuje, jak utworzyć podstawowy system projektu. Ten przewodnik opiera się na podstawowym systemie projektu przez dodanie szablonu programu Visual Studio, strony właściwości i innych funkcji. Przed rozpoczęciem tego należy ukończyć pierwszy przewodnik.

W tym przewodniku pokazano, jak utworzyć typ projektu, który ma rozszerzenie nazwy pliku projektu .myproj. Aby ukończyć przewodnik, nie musisz tworzyć własnego języka, ponieważ przewodnik jest pożyczony z istniejącego systemu projektu Visual C#.

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

Tworzenie szablonu programu Visual Studio.
Wdrażanie szablonu programu Visual Studio.
Utwórz węzeł podrzędny typu projektu w oknie dialogowym Nowy projekt .
Włącz podstawianie parametrów w szablonie programu Visual Studio.
Utwórz stronę właściwości projektu.

Uwaga

Kroki opisane w tym przewodniku są oparte na projekcie języka C#. Jednak z wyjątkiem specyfiki, takich jak rozszerzenia nazw plików i kod, można użyć tych samych kroków dla projektu Visual Basic.

Tworzenie szablonu programu Visual Studio

Tworzenie podstawowego systemu projektu, część 1 pokazuje, jak utworzyć podstawowy szablon projektu i dodać go do systemu projektu. Pokazano również, jak zarejestrować ten szablon w programie Visual Studio przy użyciu atrybutu ProvideProjectFactoryAttribute , który zapisuje pełną ścieżkę folderu \Templates\Projects\SimpleProject\ w rejestrze systemowym.

Korzystając z szablonu programu Visual Studio (pliku vstemplate ) zamiast podstawowego szablonu projektu, możesz kontrolować sposób wyświetlania szablonu w oknie dialogowym Nowy projekt i sposób zastępowania parametrów szablonu. Plik vstemplate to plik XML opisujący sposób dołączania plików źródłowych podczas tworzenia projektu przy użyciu szablonu systemu projektu. Sam system projektu jest kompilowany przez zebranie pliku vstemplate i plików źródłowych w pliku zip oraz wdrożenie przez skopiowanie pliku zip do lokalizacji znanej programowi Visual Studio. Ten proces jest bardziej szczegółowo opisany w dalszej części tego przewodnika.

W programie Visual Studio otwórz utworzone rozwiązanie SimpleProject, postępując zgodnie z instrukcjami Tworzenie podstawowego systemu projektu, część 1.
W pliku SimpleProjectPackage.cs znajdź atrybut ProvideProjectFactory. Zastąp drugi parametr (nazwa projektu) wartością null, a czwarty parametr (ścieżka do folderu szablonu projektu) ciągiem ".\NullPath" w następujący sposób.
```
[ProvideProjectFactory(typeof(SimpleProjectFactory), null,
    "Simple Project Files (*.myproj);*.myproj", "myproj", "myproj",
    ".\\NullPath",
LanguageVsTemplate = "SimpleProject")]
```
Dodaj plik XML o nazwie SimpleProject.vstemplate do folderu \Templates\Projects\SimpleProject\ .

Zastąp zawartość pliku SimpleProject.vstemplate następującym kodem.

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

W oknie Właściwości wybierz wszystkie pięć plików w folderze \Templates\Projects\SimpleProject\ i ustaw akcję kompilacji na ZipProject.

Sekcja <TemplateData> określa lokalizację i wygląd typu projektu SimpleProject w oknie dialogowym Nowy projekt w następujący sposób:

Element <Name> nadaje szablonowi projektu nazwę SimpleProject Application.
Element <Opis> zawiera opis wyświetlany w oknie dialogowym Nowy projekt po wybraniu szablonu projektu.
Element <Icon> określa ikonę wyświetlaną razem z typem projektu SimpleProject.
Element <ProjectType> nazywa typ projektu w oknie dialogowym Nowy projekt . Ta nazwa zastępuje parametr nazwy projektu atrybutu ProvideProjectFactory.

Uwaga

Element <ProjectType> musi być zgodny z LanguageVsTemplate argumentem atrybutu ProvideProjectFactory w pliku SimpleProjectPackage.cs.

W <sekcji TemplateContent> opisano te pliki, które są generowane podczas tworzenia nowego projektu:
SimpleProject.myproj
Program.cs
Assemblyinfo.cs

Wszystkie trzy pliki mają ReplaceParameters ustawioną wartość true, co umożliwia podstawianie parametrów. Plik Program.cs ma OpenInEditor ustawioną wartość true, co powoduje otwarcie pliku w edytorze kodu podczas tworzenia projektu.

Aby uzyskać więcej informacji na temat elementów w schemacie szablonu programu Visual Studio, zobacz dokumentację schematu szablonu programu Visual Studio.

Uwaga

Jeśli projekt ma więcej niż jeden szablon programu Visual Studio, każdy szablon znajduje się w osobnym folderze. Każdy plik w tym folderze musi mieć ustawioną opcję Akcja kompilacji na ZipProject.

Dodawanie minimalnego pliku vsct

Aby rozpoznać nowy lub zmodyfikowany szablon programu Visual Studio, należy uruchomić program Visual Studio w trybie instalacji. Tryb instalacji wymaga obecności pliku vsct . W związku z tym należy dodać minimalny plik vsct do projektu.

Dodaj plik XML o nazwie SimpleProject.vsct do projektu SimpleProject.

Zastąp zawartość pliku SimpleProject.vsct następującym kodem.

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

Ustaw akcję kompilacji tego pliku na VSCTCompile. Można to zrobić tylko w pliku csproj , a nie w oknie Właściwości . Upewnij się, że akcja kompilacji tego pliku jest ustawiona na Wartość Brak w tym momencie.
1. Kliknij prawym przyciskiem myszy węzeł SimpleProject, a następnie kliknij polecenie Edytuj SimpleProject.csproj.
2. W pliku csproj znajdź element SimpleProject.vsct.
```
<None Include="SimpleProject.vsct" />
```
3. Zmień akcję kompilacji na VSCTCompile.
```
<VSCTCompile Include="SimpleProject.vsct" />
```
4. plik projektu i zamknij edytor.
5. Zapisz węzeł SimpleProject, a następnie w Eksplorator rozwiązań kliknij pozycję Załaduj ponownie projekt.

Sprawdzanie kroków kompilacji szablonu programu Visual Studio

System kompilacji projektu VSPackage zwykle uruchamia program Visual Studio w trybie instalacji, gdy plik vstemplate zostanie zmieniony lub projekt zawierający plik vstemplate zostanie ponownie skompilowany. Możesz kontynuować, ustawiając poziom szczegółowości programu MSBuild na normalny lub wyższy.

W menu Narzędzia kliknij polecenie Opcje.
Rozwiń węzeł Projekty i rozwiązania, a następnie wybierz pozycję Kompiluj i uruchom.
Ustaw szczegółowość danych wyjściowych kompilacji projektu MSBuild na Wartość Normal. Kliknij przycisk OK.
Ponownie skompiluj projekt SimpleProject.

Krok kompilacji do utworzenia pliku projektu zip powinien wyglądać podobnie do poniższego przykładu.

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

Wdrażanie szablonu programu Visual Studio

Szablony programu Visual Studio nie zawierają informacji o ścieżce. W związku z tym plik zip szablonu musi zostać wdrożony w lokalizacji znanej programowi Visual Studio. Lokalizacja folderu ProjectTemplates to zazwyczaj <%LOCALAPPDATA%>\Microsoft\VisualStudio\14.0Exp\ProjectTemplates.

Aby wdrożyć fabrykę projektu, program instalacyjny musi mieć uprawnienia administratora. Wdraża szablony w węźle instalacyjnym programu Visual Studio: ...\Microsoft Visual Studio 14.0\Common7\IDE\ProjectTemplates.

Testowanie szablonu programu Visual Studio

Przetestuj fabrykę projektów, aby sprawdzić, czy tworzy hierarchię projektu przy użyciu szablonu programu Visual Studio.

Zresetuj eksperymentalne wystąpienie zestawu VISUAL Studio SDK.

W systemie Windows 7: w menu Start znajdź folder Microsoft Visual Studio/Microsoft Visual Studio SDK/Tools , a następnie wybierz pozycję Resetuj wystąpienie eksperymentalne programu Microsoft Visual Studio.

W nowszych wersjach systemu Windows: na ekranie startowym wpisz Resetuj wersję> eksperymentalnego wystąpienia programu Microsoft Visual Studio<.
Zostanie wyświetlone okno wiersza polecenia. Po wyświetleniu wyrazów Naciśnij dowolny klawisz, aby kontynuować, kliknij przycisk ENTER. Po zamknięciu okna otwórz program Visual Studio.
Ponownie skompiluj projekt SimpleProject i rozpocznij debugowanie. Zostanie wyświetlone wystąpienie eksperymentalne.
W wystąpieniu eksperymentalnym utwórz projekt SimpleProject. W oknie dialogowym Nowy projekt wybierz pozycję SimpleProject.
Powinno zostać wyświetlone nowe wystąpienie simpleProject.

Tworzenie węzła podrzędnego typu projektu

Węzeł podrzędny można dodać do węzła typu projektu w oknie dialogowym Nowy projekt . Na przykład dla typu projektu SimpleProject można mieć węzły podrzędne dla aplikacji konsoli, aplikacji okien, aplikacji internetowych itd.

Węzły podrzędne są tworzone przez zmianę pliku projektu i dodanie <elementów podrzędnych OutputSubPath> do <elementów ZipProject> . Gdy szablon jest kopiowany podczas kompilowania lub wdrażania, każdy węzeł podrzędny staje się podfolderem folderu szablonów projektów.

W tej sekcji pokazano, jak utworzyć węzeł podrzędny konsoli dla typu projektu SimpleProject.

Zmień nazwę folderu \Templates\Projects\SimpleProject\ na \Templates\Projects\ConsoleApp\.
W oknie Właściwości wybierz wszystkie pięć plików w folderze \Templates\Projects\ConsoleApp\ i upewnij się, że akcja kompilacji jest ustawiona na ZipProject.
W pliku SimpleProject.vstemplate dodaj następujący wiersz na końcu <sekcji TemplateData> tuż przed tagiem zamykającym.
```
<NumberOfParentCategoriesToRollUp>1</NumberOfParentCategoriesToRollUp>
```
Powoduje to, że szablon aplikacja konsoli będzie wyświetlany zarówno w węźle podrzędnym konsoli, jak i w węźle nadrzędnym SimpleProject, który jest jednym poziomem powyżej węzła podrzędnego.
Zapisz plik SimpleProject.vstemplate.
W pliku csproj dodaj element <OutputSubPath> do każdego z elementów ZipProject. Zwolnij projekt, tak jak poprzednio, i edytuj plik projektu.

<Znajdź elementy ZipProject>. Do każdego <elementu ZipProject> dodaj <element OutputSubPath> i nadaj mu wartość Console. 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>

Dodaj tę grupę <właściwości> do pliku projektu:

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

Zapisz plik projektu i załaduj go ponownie.

Testowanie węzła podrzędnego typu projektu

Przetestuj zmodyfikowany plik projektu, aby sprawdzić, czy węzeł podrzędny konsoli jest wyświetlany w oknie dialogowym Nowy projekt .

Uruchom narzędzie Resetuj wystąpienie eksperymentalne programu Microsoft Visual Studio.
Ponownie skompiluj projekt SimpleProject i rozpocznij debugowanie. Powinno zostać wyświetlone wystąpienie eksperymentalne
W oknie dialogowym Nowy projekt kliknij węzeł SimpleProject. Szablon Aplikacja konsolowa powinien zostać wyświetlony w okienku Szablony .
Rozwiń węzeł SimpleProject. Powinien zostać wyświetlony węzeł podrzędny konsoli . Szablon Aplikacji SimpleProject jest nadal wyświetlany w okienku Szablony .
Kliknij przycisk Anuluj i zatrzymaj debugowanie.

Podstaw parametry szablonu projektu

Tworzenie podstawowego systemu projektu, część 1 pokazała, jak zastąpić ProjectNode.AddFileFromTemplate metodę w celu wykonania podstawowego rodzaju podstawienia parametrów szablonu. W tej sekcji dowiesz się, jak używać bardziej zaawansowanych parametrów szablonu programu Visual Studio.

Podczas tworzenia projektu przy użyciu szablonu programu Visual Studio w oknie dialogowym Nowy projekt parametry szablonu są zastępowane ciągami w celu dostosowania projektu. Parametr szablonu to specjalny token rozpoczynający się i kończący się znakiem dolara, na przykład $time$. Następujące dwa parametry są szczególnie przydatne do włączania dostosowywania w projektach opartych na szablonie:

$GUID[1–10]$ jest zastępowany przez nowy identyfikator GUID. Można określić maksymalnie 10 unikatowych identyfikatorów GUID, na przykład $guid 1$.
$safeprojectname$ to nazwa podana przez użytkownika w oknie dialogowym Nowy projekt , zmodyfikowana w celu usunięcia wszystkich niebezpiecznych znaków i spacji.

Aby uzyskać pełną listę parametrów szablonu, zobacz Parametry szablonu.

Aby zastąpić parametry szablonu projektu

W pliku SimpleProjectNode.cs usuń metodę AddFileFromTemplate .
W pliku \Templates\Projects\ConsoleApp\SimpleProject.myproj znajdź właściwość RootNamespace> i zmień <jej wartość na $safeprojectname$.
```
<RootNamespace>$safeprojectname$</RootNamespace>
```

W pliku \Templates\Projects\SimpleProject\Program.cs zastąp zawartość pliku następującym kodem:

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

Ponownie skompiluj projekt SimpleProject i rozpocznij debugowanie. Powinno zostać wyświetlone wystąpienie eksperymentalne.
Utwórz nową aplikację konsoli SimpleProject. (W Okienko Typy projektów wybierz pozycję SimpleProject. W obszarze Zainstalowane szablony programu Visual Studio wybierz pozycję Aplikacja konsolowa.

W nowo utworzonym projekcie otwórz plik Program.cs. Powinien wyglądać podobnie do poniższego (wartości identyfikatora GUID w pliku będą się różnić).

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

Tworzenie strony właściwości projektu

Możesz utworzyć stronę właściwości dla typu projektu, aby użytkownicy mogli wyświetlać i zmieniać właściwości w projektach opartych na szablonie. W tej sekcji przedstawiono sposób tworzenia strony właściwości niezależnej od konfiguracji. Ta podstawowa strona właściwości używa siatki właściwości do wyświetlania właściwości publicznych uwidacznianych w klasie strony właściwości.

Utwórz klasę strony właściwości z klasy bazowej SettingsPage . Siatka właściwości dostarczana przez klasę SettingsPage jest świadoma większości typów danych pierwotnych i wie, jak je wyświetlać. Ponadto klasa wie, SettingsPage jak utrwalać wartości właściwości w pliku projektu.

Strona właściwości utworzona w tej sekcji umożliwia zmianę i zapisanie tych właściwości projektu:

Assemblyname
Outputtype
Rootnamespace.

W pliku SimpleProjectPackage.cs dodaj ten ProvideObject atrybut do SimpleProjectPackage klasy:
```
[ProvideObject(typeof(GeneralPropertyPage))]
public sealed class SimpleProjectPackage : ProjectPackage
```
Spowoduje to zarejestrowanie klasy GeneralPropertyPage strony właściwości za pomocą modelu COM.

W pliku SimpleProjectNode.cs dodaj te dwie metody zastąpione do SimpleProjectNode klasy:

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

Obie te metody zwracają tablicę identyfikatorów GUID strony właściwości. Identyfikator GUID elementu GeneralPropertyPage jest jedynym elementem w tablicy, więc okno dialogowe Strony właściwości będzie wyświetlać tylko jedną stronę.

Dodaj plik klasy o nazwie GeneralPropertyPage.cs do projektu SimpleProject.

Zastąp zawartość tego pliku następującym kodem:

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

Klasa GeneralPropertyPage uwidacznia trzy publiczne właściwości AssemblyName, OutputType i RootNamespace. Ponieważ AssemblyName nie ma ustawionej metody, jest ona wyświetlana jako właściwość tylko do odczytu. OutputType jest wyliczona stała, więc jest wyświetlana jako lista rozwijana.

Klasa bazowa SettingsPage zapewnia ProjectMgr utrwalanie właściwości. Metoda BindProperties używa ProjectMgr metody , aby pobrać utrwalone wartości właściwości i ustawić odpowiednie właściwości. Metoda ApplyChanges używa ProjectMgr metody do pobierania wartości właściwości i utrwalania ich w pliku projektu. Metoda zestawu właściwości ustawia IsDirty wartość true, aby wskazać, że właściwości muszą być utrwalane. Trwałość występuje podczas zapisywania projektu lub rozwiązania.

Ponownie skompiluj rozwiązanie SimpleProject i rozpocznij debugowanie. Powinno zostać wyświetlone wystąpienie eksperymentalne.
W wystąpieniu eksperymentalnym utwórz nową aplikację SimpleProject.
Program Visual Studio wywołuje fabrykę projektu w celu utworzenia projektu przy użyciu szablonu programu Visual Studio. Nowy plik Program.cs jest otwierany w edytorze kodu.
Kliknij prawym przyciskiem myszy węzeł projektu w Eksplorator rozwiązań, a następnie kliknij polecenie Właściwości. Wyświetli się okno dialogowe Strony właściwości.

Testowanie strony właściwości projektu

Teraz możesz sprawdzić, czy można modyfikować i zmieniać wartości właściwości.

W oknie dialogowym Strony właściwości MyConsoleApplication zmień wartość DefaultNamespace na MyApplication.
Wybierz właściwość OutputType, a następnie wybierz pozycję Biblioteka klas.
Kliknij Zastosuj a następnie kliknij OK.
Otwórz ponownie okno dialogowe Strony właściwości i sprawdź, czy zmiany zostały utrwalone.
Zamknij eksperymentalne wystąpienie programu Visual Studio.
Otwórz ponownie wystąpienie eksperymentalne.
Otwórz ponownie okno dialogowe Strony właściwości i sprawdź, czy zmiany zostały utrwalone.
Zamknij eksperymentalne wystąpienie programu Visual Studio.

Udostępnij za pośrednictwem