Návod: vytvoření souboru projektu MSBuild od začátkuWalkthrough: Create an MSBuild project file from scratch

Programovací jazyky, které cílí na .NET Framework používají soubory projektu MSBuild k popisu a řízení procesu sestavení aplikace.Programming languages that target the .NET Framework use MSBuild project files to describe and control the application build process. Při použití sady Visual Studio k vytvoření souboru projektu MSBuild je do souboru automaticky přidáno příslušné XML.When you use Visual Studio to create an MSBuild project file, the appropriate XML is added to the file automatically. Může však být užitečné pochopit, jak je kód XML uspořádán a jak jej lze změnit pro řízení sestavení.However, you may find it helpful to understand how the XML is organized and how you can change it to control a build.

Informace o vytvoření souboru projektu pro projekt C++ naleznete v tématu MSBuild (C++).For information about creating a project file for a C++ project, see MSBuild (C++).

Tento návod ukazuje, jak vytvořit soubor základního projektu přírůstkově pomocí pouze textového editoru.This walkthrough shows how to create a basic project file incrementally, by using only a text editor. Tento návod se skládá z těchto kroků:The walkthrough follows these steps:

  1. Rozšíří proměnnou prostředí PATH.Extend the PATH environment variable.

  2. Vytvořte zdrojový soubor minimální aplikace.Create a minimal application source file.

  3. Vytvořte minimální soubor projektu MSBuild.Create a minimal MSBuild project file.

  4. Sestavte aplikaci pomocí souboru projektu.Build the application by using the project file.

  5. Přidejte vlastnosti pro řízení sestavení.Add properties to control the build.

  6. Řízení sestavení změnou hodnot vlastností.Control the build by changing property values.

  7. Přidejte cíle do sestavení.Add targets to the build.

  8. Řízení sestavení zadáním cílů.Control the build by specifying targets.

  9. Přírůstkové sestavení.Build incrementally.

Tento návod ukazuje, jak sestavit projekt na příkazovém řádku a prohlédnout si výsledky.This walkthrough shows how to build the project at the command prompt and examine the results. Další informace o nástroji MSBuild a o tom, jak spustit MSBuild v příkazovém řádku, naleznete v tématu Návod: použití nástroje MSBuild.For more information about MSBuild and how to run MSBuild at the command prompt, see Walkthrough: Use MSBuild.

Chcete-li dokončit tento návod, je nutné mít nainstalovanou aplikaci Visual Studio, protože obsahuje MSBuild a kompilátor Visual C#, které jsou požadovány pro návod.To complete the walkthrough, you must have Visual Studio installed because it includes MSBuild and the Visual C# compiler, which are required for the walkthrough.

Rozšíří cestuExtend the path

Než budete moct použít MSBuild, musíte proměnnou prostředí PATH zvětšit tak, aby zahrnovala všechny požadované nástroje.Before you can use MSBuild, you must extend the PATH environment variable to include all the required tools. Můžete použít Developer Command Prompt pro Visual Studio .You can use the Developer Command Prompt for Visual Studio . Vyhledejte ji ve Windows 10 ve vyhledávacím poli na panelu úloh Windows.Search for it on Windows 10 in the search box in the Windows task bar. Chcete-li nastavit prostředí v běžném příkazovém řádku nebo ve skriptovacím prostředí, spusťte VSDevCmd.bat v podsložce Common7/Tools instalace sady Visual Studio.To set up the environment in an ordinary command prompt or in a scripting environment, run VSDevCmd.bat in the Common7/Tools subfolder of a Visual Studio installation.

Vytvoření minimální aplikaceCreate a minimal application

V této části se dozvíte, jak vytvořit zdrojový soubor aplikace s minimálním jazykem C# pomocí textového editoru.This section shows how to create a minimal C# application source file by using a text editor.

  1. Na příkazovém řádku přejděte do složky, ve které chcete vytvořit aplikaci, například \My Documents \ nebo \Plocha \ .At the command prompt, browse to the folder where you want to create the application, for example, \My Documents\ or \Desktop\ .

  2. Zadejte MD HelloWorld pro vytvoření podsložky s názvem \HelloWorld \ .Type md HelloWorld to create a subfolder named \HelloWorld\ .

  3. Zadejte CD HelloWorld pro změnu do nové složky.Type cd HelloWorld to change to the new folder.

  4. Spusťte Poznámkový blok nebo jiný textový editor a poté zadejte následující kód.Start Notepad or another text editor, and then type the following code.

    using System;
    
    class HelloWorld
    {
        static void Main()
        {
    #if DebugConfig
            Console.WriteLine("WE ARE IN THE DEBUG CONFIGURATION");
    #endif
    
            Console.WriteLine("Hello, world!");
        }
    }
    
  5. Uložte tento soubor zdrojového kódu a pojmenujte ho HelloWorld.cs .Save this source code file and name it Helloworld.cs .

  6. Sestavte aplikaci zadáním csc HelloWorld.cs na příkazovém řádku.Build the application by typing csc helloworld.cs at the command prompt.

  7. Otestujte aplikaci zadáním HelloWorld na příkazovém řádku.Test the application by typing helloworld at the command prompt.

    Hello, World!The Hello, world! měla by se zobrazit zpráva.message should be displayed.

  8. Odstraňte aplikaci zadáním příkazu del helloworld.exe v příkazovém řádku.Delete the application by typing del helloworld.exe at the command prompt.

Vytvořit minimální soubor projektu MSBuildCreate a minimal MSBuild project file

Teď, když máte minimální zdrojový soubor aplikace, můžete vytvořit minimální soubor projektu pro sestavení aplikace.Now that you have a minimal application source file, you can create a minimal project file to build the application. Tento soubor projektu obsahuje následující prvky:This project file contains the following elements:

  • Požadovaný kořenový Project uzel.The required root Project node.

  • ItemGroupUzel, který obsahuje prvky položky.An ItemGroup node to contain item elements.

  • Element Item, který odkazuje na zdrojový soubor aplikace.An item element that refers to the application source file.

  • TargetUzel, který obsahuje úlohy, které jsou požadovány k sestavení aplikace.A Target node to contain tasks that are required to build the application.

  • TaskPrvek pro spuštění kompilátoru Visual C# pro sestavení aplikace.A Task element to start the Visual C# compiler to build the application.

Vytvoření minimálního souboru projektu MSBuildTo create a minimal MSBuild project file

  1. V textovém editoru nahraďte existující text pomocí těchto dvou řádků:In the text editor, replace the existing text by using these two lines:

    <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    </Project>
    
  2. Vložte tento ItemGroup uzel jako podřízený prvek Project uzlu:Insert this ItemGroup node as a child element of the Project node:

    <ItemGroup>
      <Compile Include="helloworld.cs" />
    </ItemGroup>
    

    Všimněte si, že ItemGroup již obsahuje element Item.Notice that this ItemGroup already contains an item element.

  3. Přidejte Target uzel jako podřízený prvek Project uzlu.Add a Target node as a child element of the Project node. Pojmenujte uzel Build .Name the node Build.

    <Target Name="Build">
    </Target>
    
  4. Vložte tento element Task jako podřízený prvek Target uzlu:Insert this task element as a child element of the Target node:

    <Csc Sources="@(Compile)"/>
    
  5. Uložte tento soubor projektu a pojmenujte ho HelloWorld. csproj .Save this project file and name it Helloworld.csproj .

Váš minimální soubor projektu by měl vypadat podobně jako následující kód:Your minimal project file should resemble the following code:

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <Compile Include="helloworld.cs" />
  </ItemGroup>
  <Target Name="Build">
    <Csc Sources="@(Compile)"/>  
  </Target>
</Project>

Úlohy v cíli sestavení jsou spouštěny postupně.Tasks in the Build target are executed sequentially. V tomto případě je úkol kompilátoru Visual C# Csc jediným úkolem.In this case, the Visual C# compiler Csc task is the only task. Očekává seznam zdrojových souborů, které mají být zkompilovány, a je dána hodnotou Compile položky.It expects a list of source files to compile, and this is given by the value of the Compile item. CompilePoložka odkazuje pouze na jeden zdrojový soubor HelloWorld.cs .The Compile item references just one source file, Helloworld.cs .

Poznámka

V elementu Item můžete použít zástupný znak hvězdičky ( * ) pro odkazování na všechny soubory, které mají příponu názvu souboru . cs následujícím způsobem:In the item element, you can use the asterisk wildcard character (*) to reference all files that have the .cs file name extension, as follows:

<Compile Include="*.cs" />

Sestavení aplikaceBuild the application

Nyní k sestavení aplikace použijte soubor projektu, který jste právě vytvořili.Now, to build the application, use the project file that you just created.

  1. Na příkazovém řádku zadejte MSBuild HelloWorld. csproj-t:Build .At the command prompt, type msbuild helloworld.csproj -t:Build .

    Tím se vytvoří cíl sestavení souboru projektu HelloWorld vyvoláním kompilátoru Visual C# pro vytvoření aplikace HelloWorld.This builds the Build target of the Helloworld project file by invoking the Visual C# compiler to create the Helloworld application.

  2. Otestujte aplikaci zadáním HelloWorld .Test the application by typing helloworld .

    Hello, World!The Hello, world! měla by se zobrazit zpráva.message should be displayed.

Poznámka

Další podrobnosti o sestavení můžete zobrazit zvýšením úrovně podrobností.You can see more details about the build by increasing the verbosity level. Chcete-li nastavit úroveň podrobností na "podrobné", zadejte tento příkaz na příkazovém řádku:To set the verbosity level to "detailed", type this command at the command prompt:

MSBuild HelloWorld. csproj-t:Build-detailed: detailedmsbuild helloworld.csproj -t:Build -verbosity:detailed

Přidat vlastnosti sestaveníAdd build properties

Můžete přidat vlastnosti sestavení do souboru projektu k dalšímu řízení sestavení.You can add build properties to the project file to further control the build. Nyní přidejte tyto vlastnosti:Now add these properties:

  • AssemblyNameVlastnost, která určuje název aplikace.An AssemblyName property to specify the name of the application.

  • OutputPathVlastnost, která určuje složku, do které má být aplikace obsažena.An OutputPath property to specify a folder to contain the application.

Přidání vlastností sestaveníTo add build properties

  1. Odstraňte existující aplikaci zadáním příkazu del helloworld.exe v příkazovém řádku.Delete the existing application by typing del helloworld.exe at the command prompt.

  2. V souboru projektu vložte tento PropertyGroup prvek hned za otevřený Project element:In the project file, insert this PropertyGroup element just after the opening Project element:

    <PropertyGroup>
      <AssemblyName>MSBuildSample</AssemblyName>
      <OutputPath>Bin\</OutputPath>
    </PropertyGroup>
    
  3. Přidejte tento úkol do cíle sestavení těsně před Csc úlohu:Add this task to the Build target, just before the Csc task:

    <MakeDir Directories="$(OutputPath)"      Condition="!Exists('$(OutputPath)')" />
    

    MakeDirÚloha vytvoří složku, která je pojmenována OutputPath vlastností za předpokladu, že v tuto chvíli neexistuje žádná složka s tímto názvem.The MakeDir task creates a folder that is named by the OutputPath property, provided that no folder by that name currently exists.

  4. Přidejte tento OutputAssembly atribut do Csc úlohy:Add this OutputAssembly attribute to the Csc task:

    <Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
    

    To instruuje kompilátor Visual C#, aby vytvořil sestavení s názvem AssemblyName vlastností a umístil ho do složky, která je pojmenována OutputPath vlastností.This instructs the Visual C# compiler to produce an assembly that is named by the AssemblyName property and to put it in the folder that is named by the OutputPath property.

  5. Uložte provedené změny.Save your changes.

Soubor projektu by měl nyní vypadat podobně jako následující kód:Your project file should now resemble the following code:

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <AssemblyName>MSBuildSample</AssemblyName>
    <OutputPath>Bin\</OutputPath>
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="helloworld.cs" />
  </ItemGroup>
  <Target Name="Build">
    <MakeDir Directories="$(OutputPath)" Condition="!Exists('$(OutputPath)')" />
    <Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
  </Target>
</Project>

Poznámka

Doporučujeme přidat oddělovač cest zpětného lomítka ( \ ) na konec názvu složky při jeho zadání v OutputPath elementu namísto přidání do OutputAssembly atributu Csc úlohy.We recommend that you add the backslash (\) path delimiter at the end of the folder name when you specify it in the OutputPath element, instead of adding it in the OutputAssembly attribute of the Csc task. Z toho plyne:Therefore,

<OutputPath>Bin\</OutputPath>

OutputAssembly="$(OutputPath)$(AssemblyName).exe" />

je lepší nežis better than

<OutputPath>Bin</OutputPath>

OutputAssembly="$(OutputPath)\$(AssemblyName).exe" />

Testování vlastností sestaveníTest the build properties

Nyní můžete sestavit aplikaci pomocí souboru projektu, ve kterém jste použili vlastnosti sestavení k určení výstupní složky a názvu aplikace.Now you can build the application by using the project file in which you used build properties to specify the output folder and application name.

  1. Na příkazovém řádku zadejte MSBuild HelloWorld. csproj-t:Build .At the command prompt, type msbuild helloworld.csproj -t:Build .

    Tím se vytvoří Složka \ \Bin a potom se kompilátor Visual C# vyvolá, aby se vytvořila aplikace aplikaci MSBuildSample a umístí se do složky \ \Bin .This creates the \Bin\ folder and then invokes the Visual C# compiler to create the MSBuildSample application and puts it in the \Bin\ folder.

  2. Chcete-li ověřit, zda byla vytvořena složka \Bin \ a zda obsahuje aplikaci aplikaci MSBuildSample , zadejte příkaz dir bin .To verify that the \Bin\ folder has been created, and that it contains the MSBuildSample application, type dir Bin .

  3. Otestujte aplikaci zadáním Bin\MSBuildSample .Test the application by typing Bin\MSBuildSample .

    Hello, World!The Hello, world! měla by se zobrazit zpráva.message should be displayed.

Přidat cíle sestaveníAdd build targets

Dále přidejte do souboru projektu dva další cíle následujícím způsobem:Next, add two more targets to the project file, as follows:

  • Čistý cíl, který odstraní staré soubory.A Clean target that deletes old files.

  • Cíl opětovného sestavení, který používá DependsOnTargets atribut k vynucení spuštění úlohy čištění před úlohou sestavení.A Rebuild target that uses the DependsOnTargets attribute to force the Clean task to run before the Build task.

Teď, když máte více cílů, můžete nastavit cíl sestavení jako výchozí cíl.Now that you have multiple targets, you can set the Build target as the default target.

Přidání cílů sestaveníTo add build targets

  1. V souboru projektu přidejte tyto dva cíle hned po cíli sestavení:In the project file, add these two targets just after the Build target:

    <Target Name="Clean" >
      <Delete Files="$(OutputPath)$(AssemblyName).exe" />
    </Target>
    <Target Name="Rebuild" DependsOnTargets="Clean;Build" />
    

    Cíl vyčištění vyvolá úlohu odstranění pro odstranění aplikace.The Clean target invokes the Delete task to delete the application. Cíl opětovného sestavení se nespustí, dokud se nespustí plán vyčištění i cíl sestavení.The Rebuild target does not run until both the Clean target and the Build target have run. I když cíl opětovného sestavení nemá žádné úkoly, způsobí, že se čistý cíl spustí před cílem sestavení.Although the Rebuild target has no tasks, it causes the Clean target to run before the Build target.

  2. Přidejte tento DefaultTargets atribut do otevřeného Project elementu:Add this DefaultTargets attribute to the opening Project element:

    <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    

    Tím se nastaví cíl sestavení jako výchozí cíl.This sets the Build target as the default target.

Soubor projektu by měl nyní vypadat podobně jako následující kód:Your project file should now resemble the following code:

<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <AssemblyName>MSBuildSample</AssemblyName>
    <OutputPath>Bin\</OutputPath>
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="helloworld.cs" />
  </ItemGroup>
  <Target Name="Build">
    <MakeDir Directories="$(OutputPath)" Condition="!Exists('$(OutputPath)')" />
    <Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
  </Target>
  <Target Name="Clean" >
    <Delete Files="$(OutputPath)$(AssemblyName).exe" />
  </Target>
  <Target Name="Rebuild" DependsOnTargets="Clean;Build" />
</Project>

Testování cílů sestaveníTest the build targets

Nové cíle sestavení můžete vykonat pro otestování těchto funkcí souboru projektu:You can exercise the new build targets to test these features of the project file:

  • Sestavení výchozího sestavení.Building the default build.

  • Nastavení názvu aplikace v příkazovém řádku.Setting the application name at the command prompt.

  • Odstranění aplikace před sestavením jiné aplikace.Deleting the application before another application is built.

  • Odstranění aplikace bez sestavování jiné aplikace.Deleting the application without building another application.

Testování cílů sestaveníTo test the build targets

  1. Na příkazovém řádku zadejte MSBuild HelloWorld. csproj-p:AssemblyName = Greetings .At the command prompt, type msbuild helloworld.csproj -p:AssemblyName=Greetings .

    Vzhledem k tomu, že jste nepoužili přepínač -t k explicitnímu nastavení cíle, nástroj MSBuild spustí výchozí cíl sestavení.Because you did not use the -t switch to explicitly set the target, MSBuild runs the default Build target. Přepínač -p Přepisuje AssemblyName vlastnost a přidělí jí novou hodnotu, Greetings .The -p switch overrides the AssemblyName property and gives it the new value, Greetings. To způsobí, že se ve složce \Bin \ vytvoří nová aplikace, Greetings.exe .This causes a new application, Greetings.exe , to be created in the \Bin\ folder.

  2. Chcete-li ověřit, zda složka \ \Bin obsahuje aplikaci aplikaci MSBuildSample i novou aplikaci Greetings , zadejte příkaz dir bin .To verify that the \Bin\ folder contains both the MSBuildSample application and the new Greetings application, type dir Bin .

  3. Otestujte aplikaci Greetings zadáním Bin\Greetings .Test the Greetings application by typing Bin\Greetings .

    Hello, World!The Hello, world! měla by se zobrazit zpráva.message should be displayed.

  4. Odstraňte aplikaci aplikaci MSBuildSample zadáním MSBuild Hello. csproj-t:Clean .Delete the MSBuildSample application by typing msbuild helloworld.csproj -t:clean .

    Tím se spustí úloha vyčistit pro odebrání aplikace, která má výchozí AssemblyName hodnotu vlastnosti MSBuildSample .This runs the Clean task to remove the application that has the default AssemblyName property value, MSBuildSample.

  5. Odstraňte aplikaci Greetings zadáním MSBuild Hello. csproj-t:Clean-p:AssemblyName = Greetings .Delete the Greetings application by typing msbuild helloworld.csproj -t:clean -p:AssemblyName=Greetings .

    Tím se spustí úloha vyčistit pro odebrání aplikace, která má zadanou hodnotu vlastnosti AssemblyName Greetings .This runs the Clean task to remove the application that has the given AssemblyName property value, Greetings.

  6. Chcete-li ověřit, zda je složka \ \Bin nyní prázdná, zadejte příkaz dir bin .To verify that the \Bin\ folder is now empty, type dir Bin .

  7. Zadejte MSBuild .Type msbuild .

    I když není zadán soubor projektu, MSBuild sestaví soubor HelloWorld. csproj , protože aktuální složka obsahuje pouze jeden soubor projektu.Although a project file is not specified, MSBuild builds the helloworld.csproj file because there is only one project file in the current folder. To způsobí, že se aplikace aplikaci MSBuildSample vytvoří ve složce \Bin \ .This causes the MSBuildSample application to be created in the \Bin\ folder.

    Chcete-li ověřit, zda složka \Bin \ obsahuje aplikaci aplikaci MSBuildSample , zadejte příkaz dir bin .To verify that the \Bin\ folder contains the MSBuildSample application, type dir Bin .

Přírůstkové sestavováníBuild incrementally

Nástroj MSBuild můžete sdělit, aby vytvořil cíl pouze v případě, že se změnily zdrojové soubory nebo cílové soubory, na kterých je cíl závislý.You can tell MSBuild to build a target only if the source files or target files that the target depends on have changed. Nástroj MSBuild používá časové razítko souboru k určení, zda došlo ke změně.MSBuild uses the time stamp of a file to determine whether it has changed.

Přírůstkové sestaveníTo build incrementally

  1. V souboru projektu přidejte tyto atributy do úvodního cíle sestavení:In the project file, add these attributes to the opening Build target:

    Inputs="@(Compile)" Outputs="$(OutputPath)$(AssemblyName).exe"
    

    To určuje, že cíl sestavení závisí na vstupních souborech, které jsou zadány ve Compile skupině položek a zda je výstupním cílem soubor aplikace.This specifies that the Build target depends on the input files that are specified in the Compile item group, and that the output target is the application file.

    Výsledný cíl sestavení by měl vypadat podobně jako následující kód:The resulting Build target should resemble the following code:

    <Target Name="Build" Inputs="@(Compile)" Outputs="$(OutputPath)$(AssemblyName).exe">
      <MakeDir Directories="$(OutputPath)" Condition="!Exists('$(OutputPath)')" />
      <Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
    </Target>
    
  2. Otestujte cíl sestavení zadáním MSBuild-v:d do příkazového řádku.Test the Build target by typing msbuild -v:d at the command prompt.

    Nezapomeňte, že HelloWorld. csproj je výchozí soubor projektu a toto sestavení je výchozí cíl.Remember that helloworld.csproj is the default project file, and that Build is the default target.

    Přepínač -v:d určuje podrobný popis procesu sestavení.The -v:d switch specifies a verbose description for the build process.

    Tyto řádky by měly být zobrazeny:These lines should be displayed:

    Vynechává se cíl "Build", protože všechny výstupní soubory jsou aktuální s ohledem na vstupní soubory.Skipping target "Build" because all output files are up-to-date with respect to the input files.

    Vstupní soubory: HelloWorld.csInput files: HelloWorld.cs

    Výstupní soubory: BinMSBuildSample.exeOutput files: BinMSBuildSample.exe

    MSBuild přeskočí cíl sestavení, protože žádný ze zdrojových souborů se od posledního sestavení aplikace nezměnil.MSBuild skips the Build target because none of the source files have changed since the application was last built.

Příklad jazyka C#C# example

Následující příklad ukazuje soubor projektu, který zkompiluje aplikaci v jazyce C# a zaznamená zprávu, která obsahuje název výstupního souboru.The following example shows a project file that compiles a C# application and logs a message that contains the output file name.

KódCode

<Project DefaultTargets = "Compile"
    xmlns="http://schemas.microsoft.com/developer/msbuild/2003" >

    <!-- Set the application name as a property -->
    <PropertyGroup>
        <appname>HelloWorldCS</appname>
    </PropertyGroup>

    <!-- Specify the inputs by type and file name -->
    <ItemGroup>
        <CSFile Include = "consolehwcs1.cs"/>
    </ItemGroup>

    <Target Name = "Compile">
        <!-- Run the Visual C# compilation using input files of type CSFile -->
        <CSC
            Sources = "@(CSFile)"
            OutputAssembly = "$(appname).exe">
            <!-- Set the OutputAssembly attribute of the CSC task
            to the name of the executable file that is created -->
            <Output
                TaskParameter = "OutputAssembly"
                ItemName = "EXEFile" />
        </CSC>
        <!-- Log the file name of the output file -->
        <Message Text="The output file is @(EXEFile)"/>
    </Target>
</Project>

Příklad Visual BasicVisual Basic example

Následující příklad ukazuje soubor projektu, který zkompiluje Visual Basic aplikace a zaznamená zprávu, která obsahuje název výstupního souboru.The following example shows a project file that compiles a Visual Basic application and logs a message that contains the output file name.

KódCode

<Project DefaultTargets = "Compile"
    xmlns="http://schemas.microsoft.com/developer/msbuild/2003" >

    <!-- Set the application name as a property -->
    <PropertyGroup>
        <appname>HelloWorldVB</appname>
    </PropertyGroup>

    <!-- Specify the inputs by type and file name -->
    <ItemGroup>
        <VBFile Include = "consolehwvb1.vb"/>
    </ItemGroup>

    <Target Name = "Compile">
        <!-- Run the Visual Basic compilation using input files of type VBFile -->
        <VBC
            Sources = "@(VBFile)"
            OutputAssembly= "$(appname).exe">
            <!-- Set the OutputAssembly attribute of the VBC task
            to the name of the executable file that is created -->
            <Output
                TaskParameter = "OutputAssembly"
                ItemName = "EXEFile" />
        </VBC>
        <!-- Log the file name of the output file -->
        <Message Text="The output file is @(EXEFile)"/>
    </Target>
</Project>

Co dále?What's next?

Visual Studio může automaticky provádět spoustu práce, která je uvedená v tomto návodu.Visual Studio can automatically do much of the work that is shown in this walkthrough. Informace o tom, jak používat Visual Studio k vytváření, úpravám, sestavování a testování souborů projektu MSBuild, najdete v tématu Návod: použití nástroje MSBuild.To learn how to use Visual Studio to create, edit, build, and test MSBuild project files, see Walkthrough: Use MSBuild.

Viz takéSee also