Share via

Vytvoření základního projektového systému, část 1

  • Článek

V sadě Visual Studio jsou projekty kontejnery, které vývojáři používají k uspořádání souborů zdrojového kódu a dalších prostředků. Projekty se v Průzkumník řešení zobrazují jako podřízené řešení. Projekty umožňují organizovat, sestavovat, ladit a nasazovat zdrojový kód a vytvářet odkazy na webové služby, databáze a další prostředky.

Projekty jsou definovány v souborech projektu, například v souboru .csproj pro projekt Visual C#. Můžete vytvořit vlastní typ projektu, který má vlastní příponu názvu souboru projektu. Další informace o typech projektů naleznete v tématu Typy projektů.

Poznámka:

Pokud potřebujete sadu Visual Studio rozšířit o vlastní typ projektu, důrazně doporučujeme využít systém projektů sady Visual Studio (VSPS), který má řadu výhod oproti vytvoření systému projektů od začátku:

  • Snadnější onboarding. I základní projektový systém vyžaduje desítky tisíc řádků kódu. Využití VSPS snižuje náklady na onboarding na několik kliknutí, než budete připraveni ho přizpůsobit vašim potřebám.

  • Jednodušší údržba. Využíváním VSPS stačí udržovat jen vlastní scénáře. Zpracováváme upkeep všech projektových systémových infrastruktur.

    Pokud potřebujete cílit na verze sady Visual Studio starší než Visual Studio 2013, nebudete moct využívat VSPS v rozšíření sady Visual Studio. V takovém případě je tento názorný postup vhodným místem, kde začít.

Tento návod ukazuje, jak vytvořit typ projektu, který má příponu souboru projektu .myproj. Tento názorný postup si půjčí z existujícího systému projektů Visual C#.

Poznámka:

Další příklady projektů rozšíření najdete v ukázkách sady VSSDK.

V tomto názorném postupu se naučíte, jak provádět tyto úlohy:

  • Vytvořte základní typ projektu.

  • Vytvořte základní šablonu projektu.

  • Zaregistrujte šablonu projektu v sadě Visual Studio.

  • Vytvořte instanci projektu tak, že otevřete dialogové okno Nový projekt a pak použijete šablonu.

  • Vytvořte projektovou továrnu pro systém projektů.

  • Vytvořte uzel projektu pro systém projektu.

  • Přidejte vlastní ikony pro systém projektu.

  • Implementace nahrazení parametrů základní šablony

Požadavky

Stáhněte zdrojový kód pro architekturu spravovaných balíčků pro projekty. Extrahujte soubor do umístění, které je přístupné pro řešení, které vytvoříte.

Vytvoření základního typu projektu

Vytvořte projekt VSIX jazyka C# s názvem SimpleProject. (Vytvořte>nový>projekt a pak visual C#>Extensibility>VSIX Project). Přidejte šablonu položky projektu balíčku sady Visual Studio (na Průzkumník řešení klikněte pravým tlačítkem myši na uzel projektu a vyberte Přidat>novou položku a pak přejděte na Rozšiřitelnost>balíčku sady Visual Studio). Pojmenujte soubor SimpleProjectPackage.

Vytvoření základní šablony projektu

Teď můžete tento základní balíček VSPackage upravit tak, aby implementoval nový typ projektu .myproj . Pokud chcete vytvořit projekt založený na typu projektu .myproj , musí Visual Studio vědět, které soubory, zdroje a odkazy se mají přidat do nového projektu. Chcete-li tyto informace poskytnout, umístěte soubory projektu do složky šablony projektu. Když uživatel použije projekt .myproj k vytvoření projektu, soubory se zkopírují do nového projektu.

Vytvoření základní šablony projektu

  1. Přidejte do projektu tři složky, jednu pod druhou: Templates\Projects\SimpleProject. (V Průzkumník řešení klepněte pravým tlačítkem myši na uzel projektu SimpleProject, přejděte na příkaz Přidat a klepněte na tlačítko Nová složka. Pojmenujte šablony složek. Do složky Šablony přidejte složku s názvem Projekty. Do složky Projekty přidejte složku s názvem SimpleProject.)

  2. Do složky Templates\Projects\SimpleProject přidejte soubor bitmapového obrázku, který chcete použít jako ikonu s názvem SimpleProject.ico. Když kliknete na Přidat, otevře se editor ikon.

  3. Zvýraznit ikonu. Tato ikona se zobrazí v dialogovém okně Nový projekt později v návodu.

    Simple Project Icon

  4. Uložte ikonu a zavřete editor ikon.

  5. Do složky Templates\Projects\SimpleProject přidejte položku třídy s názvem Program.cs.

  6. Nahraďte stávající kód následujícími řádky.

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

    Důležité

    Nejedná se o konečnou formu kódu Program.cs . Náhradní parametry budou řešeny v pozdějším kroku. Můžou se zobrazit chyby kompilace, ale pokud je BuildAction souboru Obsah, měli byste být schopni sestavit a spustit projekt obvyklým způsobem.

  7. Uložte soubor.

  8. Zkopírujte soubor AssemblyInfo.cs ze složky Vlastnosti do složky Projects\SimpleProject.

  9. Do složky Projects\SimpleProject přidejte soubor XML s názvem SimpleProject.myproj.

    Poznámka:

    Přípona názvu souboru pro všechny projekty tohoto typu je .myproj. Pokud ho chcete změnit, musíte ho změnit všude, kde je uveden v návodu.

  10. Nahraďte existující obsah následujícími řádky.

    <?xml version="1.0" encoding="utf-8" ?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <SchemaVersion>2.0</SchemaVersion>
    <ProjectGuid></ProjectGuid>
    <OutputType>Exe</OutputType>
    <RootNamespace>MyRootNamespace</RootNamespace>
    <AssemblyName>MyAssemblyName</AssemblyName>
    <EnableUnmanagedDebugging>false</EnableUnmanagedDebugging>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
    <DebugSymbols>true</DebugSymbols>
    <OutputPath>bin\Debug\</OutputPath>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
    <DebugSymbols>false</DebugSymbols>
    <OutputPath>bin\Release\</OutputPath>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="mscorlib" />
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="AssemblyInfo.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Program.cs">
      <SubType>Code</SubType>
    </Compile>
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
</Project>

  11. Uložte soubor.

  12. V okně Vlastnosti nastavte akcisestavení AssemblyInfo.cs, Program.cs, SimpleProject.ico a SimpleProject.myproj na Content a nastavte jejich Zahrnutí do vlastností VSIX na True.

    Tato šablona projektu popisuje základní projekt Visual C#, který má konfiguraci ladění i konfiguraci vydané verze. Projekt obsahuje dva zdrojové soubory, AssemblyInfo.cs a Program.cs a několik odkazů na sestavení. Při vytvoření projektu ze šablony se hodnota ProjectGuid automaticky nahradí novým identifikátorem GUID.

    V Průzkumník řešení by se rozbalovaná složka Šablony měla zobrazit takto:

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

Vytvoření základní projektové továrny

Sadě Visual Studio musíte sdělit umístění složky šablony projektu. Chcete-li to provést, přidejte atribut třídy VSPackage, která implementuje objekt pro vytváření projektů tak, aby umístění šablony bylo zapsáno do systémového registru při sestavení VSPackage. Začněte vytvořením základní projektové továrny, která je identifikována identifikátorem GUID objektu pro vytváření projektů. Pomocí atributu ProvideProjectFactoryAttribute připojte objekt pro vytváření projektů ke SimpleProjectPackage třídě.

Vytvoření základní projektové továrny

  1. Vytvořte identifikátory GUID pro objekt pro vytváření projektů (v nabídce Nástroje klikněte na Vytvořit identifikátor GUID) nebo použijte identifikátor GUID v následujícím příkladu. Přidejte identifikátory GUID do SimpleProjectPackage třídy v blízkosti oddílu s již definovaným PackageGuidStringidentifikátorem . Identifikátory GUID musí být ve formuláři GUID i ve formuláři řetězce. Výsledný kód by měl vypadat podobně jako v následujícím příkladu.

        public sealed class SimpleProjectPackage : Package
    {
        ...
        public const string SimpleProjectPkgString = "96bf4c26-d94e-43bf-a56a-f8500b52bfad";
        public const string SimpleProjectFactoryString = "471EC4BB-E47E-4229-A789-D1F5F83B52D4";

        public static readonly Guid guidSimpleProjectFactory = new Guid(SimpleProjectFactoryString);
    }

  2. Přidejte třídu do horní složky SimpleProject s názvem SimpleProjectFactory.cs.

  3. Přidejte následující direktivy using:

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

  4. Přidejte do třídy atribut SimpleProjectFactory GUID. Hodnota atributu je nový identifikátor GUID objektu pro vytváření projektů.

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

    Teď můžete zaregistrovat šablonu projektu.

Registrace šablony projektu

  1. V SimpleProjectPackage.cs přidejte ProvideProjectFactoryAttribute atribut do SimpleProjectPackage třídy následujícím způsobem.

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

  2. Znovu sestavte řešení a ověřte, že se sestavuje bez chyb.

    Opětovné sestavení zaregistruje šablonu projektu.

    Parametry defaultProjectExtension a possibleProjectExtensions jsou nastavené na příponu názvu souboru projektu (.myproj). Parametr projectTemplatesDirectory je nastaven na relativní cestu ke složce Templates . Během sestavení se tato cesta převede na úplné sestavení a přidá se do registru pro registraci systému projektu.

Otestování registrace šablony

Registrace šablony hlásí sadě Visual Studio umístění složky šablony projektu, aby visual Studio v dialogovém okně Nový projekt zobrazilo název a ikonu šablony.

Otestování registrace šablony

  1. Stisknutím klávesy F5 spusťte ladění experimentální instance sady Visual Studio.

  2. V experimentální instanci vytvořte nový projekt nově vytvořeného typu projektu. V dialogovém okně Nový projekt byste měli vidět SimpleProject v části Nainstalované šablony.

    Teď máte objekt pro vytváření projektů, který je zaregistrovaný. Projekt však ještě nemůže vytvořit. Balíček projektu a projektová továrna spolupracují na vytvoření a inicializaci projektu.

Přidání kódu spravovaného balíčku Framework

Implementujte propojení mezi balíčkem projektu a objektem pro vytváření projektů.

  • Importujte soubory zdrojového kódu pro architekturu spravovaných balíčků.

    1. Rozbalte projekt SimpleProject (v Průzkumník řešení, vyberte uzel projektu a v místní nabídce klepněte na tlačítko Uvolnit projekt.) a otevřete soubor projektu v editoru XML.

    2. Do souboru projektu přidejte následující bloky (přímo nad bloky importu<>). Nastavte ProjectBasePath na umístění souboru ProjectBase.files v kódu Managed Package Framework, který jste právě stáhli. Možná budete muset k názvu cesty přidat zpětné lomítko. Pokud ne, může se stát, že projekt nenajde zdrojový kód rozhraní Managed Package Framework.

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

      Důležité

      Nezapomeňte na zpětné lomítko na konci cesty.

    3. Znovu načtěte projekt.

    4. Přidejte odkazy na následující sestavení:

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

      • WindowsBase

      • Microsoft.Build.Tasks.v4.0

Inicializace objektu pro vytváření projektů

  1. Do souboru SimpleProjectPackage.cs přidejte následující using direktivu.

    using Microsoft.VisualStudio.Project;

  2. Odvození SimpleProjectPackage třídy z Microsoft.VisualStudio.Package.ProjectPackage.

    public sealed class SimpleProjectPackage : ProjectPackage

  3. Zaregistrujte projektový objekt pro vytváření. Do metody přidejte následující řádek SimpleProjectPackage.Initialize hned za base.Initialize.

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

  4. Implementujte abstraktní vlastnost ProductUserContext:

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

  5. V SimpleProjectFactory.cs přidejte následující using direktivu za existující using direktivy.

    using Microsoft.VisualStudio.Project;

  6. Odvození SimpleProjectFactory třídy z ProjectFactory.

    class SimpleProjectFactory : ProjectFactory

  7. Do třídy přidejte následující fiktivní metodu SimpleProjectFactory . Tuto metodu implementujete v další části.

    protected override ProjectNode CreateProject()
{
    return null;
}

  8. Do třídy přidejte následující pole a konstruktor SimpleProjectFactory . Tento SimpleProjectPackage odkaz je uložen v mezipaměti v privátním poli, aby se mohl použít při nastavení lokality poskytovatele služeb.

    private SimpleProjectPackage package;

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

  9. Znovu sestavte řešení a ověřte, že se sestavuje bez chyb.

Otestování implementace projektové továrny

Otestujte, zda je volána konstruktor pro implementaci objektu pro vytváření projektu.

Otestování implementace projektové továrny

  1. V souboru SimpleProjectFactory.cs nastavte zarážku na následujícím řádku v konstruktoruSimpleProjectFactory.

    this.package = package;

  2. Stisknutím klávesy F5 spusťte experimentální instanci sady Visual Studio.

  3. V experimentální instanci začněte vytvářet nový projekt. V dialogovém okně Nový projekt vyberte typ projektu SimpleProject a klepněte na tlačítko OK. Provádění se zastaví na zarážce.

  4. Vymažte zarážku a zastavte ladění. Vzhledem k tomu, že jsme zatím nevytvořili uzel projektu, kód pro vytvoření projektu stále vyvolává výjimky.

Rozšíření třídy ProjectNode

Nyní můžete implementovat SimpleProjectNode třídu, která je odvozena od ProjectNode třídy. Základní ProjectNode třída zpracovává následující úlohy vytváření projektu:

  • Zkopíruje soubor šablony projektu SimpleProject.myproj do nové složky projektu. Kopie se přejmenuje podle názvu zadaného v dialogovém okně Nový projekt . Hodnota ProjectGuid vlastnosti se nahradí novým identifikátorem GUID.

  • Prochází elementy MSBuild souboru šablony projektu, SimpleProject.myproj a hledá Compile elementy. Pro každý Compile cílový soubor zkopíruje soubor do nové složky projektu.

    Odvozená SimpleProjectNode třída zpracovává tyto úlohy:

  • Umožňuje vytváření nebo výběru ikon pro uzly projektu a souborů v Průzkumník řešení.

  • Umožňuje zadat další náhrady parametrů šablony projektu.

Rozšíření třídy ProjectNode

  1. Přidejte třídu s názvem SimpleProjectNode.cs.

  2. Nahraďte stávající kód následujícím kódem.

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

    Tato SimpleProjectNode implementace třídy má tyto přepisované metody:

  • ProjectGuid, který vrátí identifikátor GUID objektu pro vytváření projektů.

  • ProjectType, který vrátí lokalizovaný název typu projektu.

  • AddFileFromTemplate, který zkopíruje vybrané soubory ze složky šablony do cílového projektu. Tato metoda se dále implementuje v další části.

    Konstruktor SimpleProjectNode , jako je SimpleProjectFactory konstruktor, ukládá SimpleProjectPackage odkaz do privátního pole pro pozdější použití.

    Chcete-li připojit SimpleProjectFactory třídu ke SimpleProjectNode třídě, musíte vytvořit instanci nové SimpleProjectNode v SimpleProjectFactory.CreateProject metodě a uložit ji do mezipaměti v privátním poli pro pozdější použití.

Připojení třídy objektu pro vytváření projektů a třídy uzlu

  1. Do souboru SimpleProjectFactory.cs přidejte následující using direktivu:

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

  2. Nahraďte metodu SimpleProjectFactory.CreateProject následujícím kódem.

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

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

  3. Znovu sestavte řešení a ověřte, že se sestavuje bez chyb.

Testování třídy ProjectNode

Otestujte projektovou továrnu a zjistěte, jestli vytváří hierarchii projektu.

Testování třídy ProjectNode

  1. Stisknutím klávesy F5 spusťte ladění. V experimentální instanci vytvořte nový SimpleProject.

  2. Visual Studio by mělo volat projektovou továrnu pro vytvoření projektu.

  3. Zavřete experimentální instanci sady Visual Studio.

Ikona přidání vlastního uzlu projektu

Ikona uzlu projektu v předchozí části je výchozí ikona. Můžete ho změnit na vlastní ikonu.

Přidání ikony vlastního uzlu projektu

  1. Do složky Resources přidejte rastrový soubor s názvem SimpleProjectNode.bmp.

  2. V oknech Vlastnosti zmenšete rastrový obrázek na 16 o 16 pixelů. Zvýraznit rastrový obrázek.

    Simple Project Comm

  3. V okně Vlastnosti změňte akci Sestavení rastrového obrázku na Vložený prostředek.

  4. Do souboru SimpleProjectNode.cs přidejte následující using direktivy:

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

  5. Do třídy přidejte následující statické pole a konstruktor SimpleProjectNode .

    private static ImageList imageList;

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

  6. Na začátek SimpleProjectNode třídy přidejte následující vlastnost.

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

  7. Nahraďte konstruktor instance následujícím kódem.

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

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

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

    Během statické výstavby SimpleProjectNode načte rastrový obrázek uzlu projektu z prostředků manifestu sestavení a uloží ho do mezipaměti v privátním poli pro pozdější použití. Všimněte si syntaxe cesty k obrázku GetManifestResourceStream . Chcete-li zobrazit názvy prostředků manifestu vložené do sestavení, použijte metodu GetManifestResourceNames . Při použití této metody na SimpleProject sestavení by výsledky měly být následující:

  • 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

    Během vytváření instancí základní ProjectNode třída načte Resources.imagelis.bmp, ve kterém jsou vloženy běžně používané 16 x 16 rastrových obrázků z Resources\imagelis.bmp. Tento rastrový seznam je zpřístupněn jako SimpleProjectNodeImageHandler.ImageList. SimpleProjectNode připojí rastrový obrázek uzlu projektu do seznamu. Posun rastrového obrázku uzlu projektu v seznamu obrázků je uložen v mezipaměti pro pozdější použití jako hodnota veřejné ImageIndex vlastnosti. Visual Studio používá tuto vlastnost k určení rastrového obrázku, který se má zobrazit jako ikona uzlu projektu.

Test ikony vlastního uzlu projektu

Otestujte projektovou továrnu a zjistěte, jestli vytvoří hierarchii projektu s ikonou vašeho vlastního uzlu projektu.

Otestování ikony vlastního uzlu projektu

  1. Spusťte ladění a v experimentální instanci vytvořte nový SimpleProject.

  2. V nově vytvořeném projektu si všimněte, že SimpleProjectNode.bmp se používá jako ikona uzlu projektu.

    Simple Project New Project Node

  3. Otevřete soubor Program.cs v editoru kódu. Měl by se zobrazit zdrojový kód podobný následujícímu kódu.

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

    Všimněte si, že parametry šablony $nameSpace$ a $className$ nemají nové hodnoty. V další části se dozvíte, jak implementovat nahrazení parametrů šablony.

Nahrazení parametrů šablony

V předchozí části jste pomocí atributu ProvideProjectFactory zaregistrovali šablonu projektu v sadě Visual Studio. Registrace cesty ke složce šablony tímto způsobem umožňuje povolit základní nahrazení parametrů šablony přepsáním a rozbalením ProjectNode.AddFileFromTemplate třídy. Další informace najdete v tématu Nová generace projektů: Pod kapotou, část 2.

Teď do třídy přidejte náhradní kód AddFileFromTemplate .

Nahrazení parametrů šablony

  1. Do souboru SimpleProjectNode.cs přidejte následující using direktivu.

    using System.IO;

  2. Nahraďte metodu AddFileFromTemplate následujícím kódem.

    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. Nastavte v metodě zarážku hned za className příkazem přiřazení.

    Příkazy přiřazení určují přiměřené hodnoty pro obor názvů a nový název třídy. ProjectNode.FileTemplateProcessor.AddReplace Dvě volání metody nahradí odpovídající hodnoty parametru šablony pomocí těchto nových hodnot.

Otestování nahrazení parametru šablony

Teď můžete otestovat nahrazení parametrů šablony.

Otestování nahrazení parametru šablony

  1. Spusťte ladění a v experimentální instanci vytvořte nový SimpleProject.

  2. Provádění se zastaví na zarážce v AddFileFromTemplate metodě.

  3. Prozkoumejte hodnoty a nameSpaceclassName parametry.

    • nameSpace je uvedena hodnota <RootNamespace> elementu v souboru šablony projektu \Templates\Projects\SimpleProject\SimpleProject.myproj . V tomto případě je MyRootNamespacehodnota .

    • className má hodnotu názvu zdrojového souboru třídy bez přípony názvu souboru. V tomto případě první soubor, který se má zkopírovat do cílové složky, je AssemblyInfo.cs; proto hodnota className je AssemblyInfo.

  4. Odeberte zarážku a stisknutím klávesy F5 pokračujte v provádění.

    Visual Studio by mělo dokončit vytváření projektu.

  5. Otevřete soubor Program.cs v editoru kódu. Měl by se zobrazit zdrojový kód podobný následujícímu kódu.

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

    Všimněte si, že obor názvů je nyní MyRootNamespace a název třídy je nyní Program.

  6. Spusťte ladění projektu. Nový projekt by se měl zkompilovat, spustit a zobrazit "Hello VSX!!" v okně konzoly.

    Simple Project Command

    Blahopřejeme! Implementovali jste základní systém spravovaných projektů.