Názorný postup: Vytvoření souboru MSBuild projektu od začátku

Programovacích jazyků tento cíl.NET Framework například Visual C# a Visual Basic, použijte soubory projektu MSBuild popsat a řízení procesu vytváření aplikace.Při vytvoření souboru MSBuild projektu pomocí aplikace Visual Studio, odpovídající XML automaticky přidán do souboru.Však bude pravděpodobně užitečné porozumět uspořádání XML a jak jej ovládat nové sestavení změnit.Tento názorný postup ukazuje, jak vytvořit soubor projektu základní postupně pomocí textového editoru.Návod zahrnuje následující kroky:

• Vytvořte zdrojový soubor aplikace minimal.

• Vytvořte minimální soubor projektu MSBuild.

• Rozšíření proměnné prostředí PATH zahrnout MSBuild.

• Vytvoření aplikace pomocí souboru projektu.

• Přidáte vlastnosti pro řízení sestavení.

• Sestavení změnou hodnot vlastností ovládacího prvku.

• Přidáte sestavení cíle.

• Ovládací prvek sestavení zadáním cíle.

• Sestavení postupně.

Tento názorný postup ukazuje, jak sestavit projekt na příkazovém řádku a přezkoumají výsledky.Další informace o MSBuild a jak spustit nástroj MSBuild příkazového řádku naleznete v Názorný postup: Pomocí nástroje MSBuild.

Chcete-li dokončit návod musí mít.NET Framework (verze 2.0, 3.5 nebo 4.0) nainstalován, protože obsahuje nástroj MSBuild a kompilátoru Visual C#, které jsou potřebné pro návod.

Vytvoření aplikace Minimal

Tato část popisuje vytvořte minimální Visual C# zdrojový soubor aplikace pomocí textového editoru.

Vytvoření aplikace minimal

1. Na příkazovém řádku přejděte do složky, kde chcete vytvořit aplikaci, například \My Documents\ nebo \Desktop\.

2. Typ md HelloWorld vytvořte podsložku s názvem \HelloWorld\.

3. Typ cd HelloWorld do nové složky.

4. Spusťte program Poznámkový blok nebo jiném textovém editoru a zadejte následující kód.

   using System;
   
   class HelloWorld
   {
       static void Main()
       {
   #if DebugConfig
           Console.WriteLine("WE ARE IN THE DEBUG CONFIGURATION");
   #endif
   
           Console.WriteLine("Hello, world!");
       }
   }
   

5. Uložit tento soubor zdrojový kód s názvem Helloworld.cs.

6. Vytvoření aplikace zadáním csc helloworld.cs na příkazovém řádku.

7. Testování aplikace zadáním helloworld na příkazovém řádku.

   Hello, world! Se zobrazit zpráva.

8. Odstranit aplikaci zadáním del helloworld.exe na příkazovém řádku.

Vytvoření souboru minimální MSBuild projektu

Zdrojový soubor aplikace minimal máte, můžete vytvořit soubor projektu minimální vytvoření aplikace.Soubor projektu obsahuje následující prvky:

• Požadované kořenové Project uzel.

• ItemGroup Uzel obsahovat položky prvky.

• Prvek položka odkazuje na soubor aplikace zdroje.

• A Target uzel obsahuje úkoly, které jsou nutné k vytvoření aplikace.

• A Task prvek spustit kompilátoru Visual C# vytvoření aplikace.

Vytvořit minimální soubor projektu MSBuild

1. V textovém editoru nahraďte existující text tyto dva řádky:

   <Project xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
   </Project>
   

2. Vložte to ItemGroup uzel jako podřízený prvek Project uzlu:

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

   Oznámení touto ItemGroup již obsahuje položku element.

3. Přidat Target uzel jako podřízený prvek Project uzel.Název uzlu sestavení.

     <Target Name="Build">
     </Target>
   

4. Tento prvek úloh Vložit jako podřízený prvek Target uzlu:

       <Csc Sources="@(Compile)"/>
   

5. Uložte soubor projektu s názvem Helloworld.csproj.

Soubor projektu minimální by měl vypadat následující kód:

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

Úkoly v cílové sestavení jsou spouštěny postupně.V tomto případě kompilátoru Visual C# Csc jedná pouze úkol.Očekává, že seznam zdrojových souborů kompilovat a je dán hodnotou Compile zboží.Compile Položka odkazuje pouze jeden zdrojový soubor Helloworld.cs.

[!POZNÁMKA]

V prvku položky lze použít zástupný znak hvězdička (*) na odkaz všechny soubory, které mají příponu názvu souboru .cs takto:

<Compile Include="*.cs" />

Však nedoporučujeme použití zástupných znaků, protože usnadňuje ladění a selektivní cílení obtížnější, pokud jsou zdrojové soubory přidány nebo odstraněny.

Zahrnout MSBuild Cesta rozšíření

Před zobrazením MSBuild musí rozšíření proměnné prostředí PATH zahrnout.NET Framework složky.

Rozšířit cesty zahrnout MSBuild

• Na příkazovém řádku zadejte následující příkaz: set PATH=%PATH%;%WINDIR%\Microsoft.Net\Framework\v4.0.Pokud máte jinou verzi.NET Framework nainstalované, změní číslo verze.

  [!POZNÁMKA]

  Název složky MSBuild počítače může obsahovat číslo sestavení, například v2.0.50727.Pokud ano, patří číslo sestavení na příkazovém řádku, například set PATH=%PATH%;%WINDIR%\Microsoft.Net\Framework\v2.0.50727.

  Alternativně, pokud máte nainstalovanou sadu Visual Studio, můžete použít Visual Studio příkazového řádku, který obsahuje cestu, která obsahuje složku MSBuild.

Vytvoření aplikace pomocí souboru projektu

Nyní chcete-li vytvořit aplikaci pomocí souboru projektu, který jste právě vytvořili.

Vytvoření aplikace

1. Na příkazovém řádku zadejte následující příkaz: msbuild helloworld.csproj /t:Build.

   Toto sestavení cílového souboru projektu aplikace Helloworld vytvoří vyvoláním kompilátoru Visual C#, můžete vytvořit aplikaci Helloworld.

2. Testování aplikace zadáním helloworld.

   Hello, world! Se zobrazit zpráva.

[!POZNÁMKA]

Zvýšit úroveň podrobnosti zobrazíte další podrobnosti o sestavení.Chcete-li nastavit podrobnost na "podrobné" zadejte buď tyto příkazy příkazového řádku:

msbuild helloworld.csproj /t:Build /verbosity:detailed

Přidání sestavení vlastností

Přidáte-li vlastnosti sestavení souboru projektu na další ovládací prvek sestavení.Přidáte tyto vlastnosti:

• AssemblyName Určuje název aplikace.

• OutputPath Vlastnosti můžete určit složku, do aplikace.

Přidat vlastnosti sestavení

1. Odstranit existující aplikaci zadáním del helloworld.exe na příkazovém řádku.

2. V souboru projektu vložit toto PropertyGroup prvek právě po zahájení Project prvek:

     <PropertyGroup>
       <AssemblyName>MSBuildSample</AssemblyName>
       <OutputPath>Bin\</OutputPath>
     </PropertyGroup>
   

3. Těsně před úkol přidat do cílové sestavení Csc úloh:

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

   MakeDir Úloh vytvoří složku s názvem OutputPath vlastnosti, které jsou k dispozici žádná složka jméno aktuálně existenci.

4. Přidat OutputAssembly k atributu Csc úloh:

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

   Tento pokyn kompilátoru Visual C# vyrábět s názvem sestavení AssemblyName vlastnosti a umístit do složky s názvem OutputPath vlastnost.

5. Uložte provedené změny.

Soubor projektu by měl nyní vypadat následující kód:

<Project xmlns="https://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č cesty zpětné lomítko (\) na konci názvu složky při zadání v OutputPath prvek namísto přidání jej OutputAssembly atribut Csc úkolu.Proto

<OutputPath>Bin\</OutputPath>

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

je lepší než

<OutputPath>Bin</OutputPath>

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

Testování vlastností sestavení

Nyní můžete vytvořit aplikaci pomocí souboru projektu použili sestavení vlastnosti zadejte název složky a aplikace výstup.

Testování vlastností sestavení

1. Na příkazovém řádku zadejte následující příkaz: msbuild helloworld.csproj /t:Build.

   To vytvoří složku \Bin\ vyvolá kompilátoru Visual C# vytvoření aplikace MSBuildSample a umístí ji do složky \Bin\.

2. Chcete-li ověřit, byl vytvořen ve složce \Bin\ a obsahuje MSBuildSample aplikace, zadejte dir Bin.

3. Testování aplikace zadáním Bin\MSBuildSample.

   Hello, world! Se zobrazit zpráva.

Přidání sestavení cíle

Dále přidejte dvě další cíle na soubor projektu takto:

• Čisté cíl, který odstraní staré soubory.

• Znovu vytvořit cíl, který používá DependsOnTargets atributu vynutit čisté úlohu před úkol sestavení.

Nyní, když máte více cílů, můžete nastavit jako výchozí cíl cílové sestavení.

Přidání sestavení cíle

1. V souboru projektu přidáte pouze po sestavení cílového tyto dva cíle:

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

   Cíl Clean vyvolá odstranit úlohu odstranit aplikaci.Až do spuštění čisté cílového a cíl sestavení nelze spustit cílové Rebuild.Přestože cíl sestavení neobsahuje žádné úkoly, způsobuje čisté cílové spustit před cílové sestavení.

2. Přidat DefaultTargets atributu pro otevírání Project prvek:

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

   Tento cíl sestavení nastaví jako výchozí cíl.

Soubor projektu by měl nyní vypadat následující kód:

<Project DefaultTargets="Build" xmlns="https://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>

Sestavení cíle testování

Může vykonávat nové sestavení cíle testování těchto funkcí soubor projektu:

• Vytváření sestavení výchozí.

• Nastavení názvu aplikace příkazového řádku.

• Odstranění aplikace před integrovaný jinou aplikací.

• Odstranění aplikace bez vytváření jiné aplikace.

Test build cíle

1. Na příkazovém řádku zadejte následující příkaz: msbuild helloworld.csproj /p:AssemblyName=Greetings.

   Protože nebyla použita /t přepnutí explicitně nastavit cíl, MSBuild spustí výchozí cíl sestavení./p Přepnout lokální změny AssemblyName vlastnosti a je mu novou hodnotu pozdravy.To způsobí nové aplikace, Greetings.exe, má být vytvořen ve složce \Bin\.

2. Chcete-li ověřit, zda složka \Bin\ obsahuje aplikace MSBuildSample a novou aplikaci Pozdravy, zadejte dir Bin.

3. Testovat aplikace pozdravy zadáním Bin\Greetings.

   Hello, world! Se zobrazit zpráva.

4. Zadáním odstranění aplikace MSBuildSample msbuild helloworld.csproj /t:clean.

   Spustí čisté úloh odebrat aplikaci, která má výchozí AssemblyName hodnotu vlastnosti MSBuildSample.

5. Odstranit aplikaci Pozdravy zadáním msbuild helloworld.csproj /t:clean /p:AssemblyName=Greetings.

   Spustí čištění úloh odebrat aplikaci, která má daném AssemblyName hodnotu vlastnosti pozdravy.

6. Chcete-li ověřit, \Bin\ složky je nyní prázdný, zadejte dir Bin.

7. Type msbuild.

   Přestože není zadán soubor projektu, MSBuild vytváří soubor helloworld.csproj protože existuje pouze jeden soubor projektu v aktuální složce.To způsobuje, že aplikace MSBuildSample vytvořen ve složce \Bin\.

   Chcete-li ověřit, zda složka \Bin\ obsahuje aplikaci MSBuildSample, zadejte následující příkaz: dir Bin.

Vytváření postupně

Poznáte MSBuild vytvářet cíle pouze v případě, že soubory zdroj nebo cíl závisí na cílové soubory se změnily.Nástroj MSBuild časové razítko souboru používá k určení, zda byl změněn.

Postupně vytvořit

1. V souboru projektu přidejte tyto atributy otevírání cílové sestavení:

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

   Určuje cílový sestavení závisí vstupní soubory, které jsou určeny v Compile skupina položek a že cílové výstupní soubor aplikace.

   Výsledné sestavení cíl by měl vypadat následující kód:

   <Target Name="Build" Inputs="@(Compile)" Outputs="$(OutputPath)$(AssemblyName).exe">
     <MakeDir Directories="$(OutputPath)" Condition="!Exists('$(OutputPath)')" />
     <Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
   </Target>
   

2. Zkušební sestavení cílového zadáním msbuild /v:d na příkazovém řádku.

   Nezapomeňte, že helloworld.csproj je výchozí soubor projektu a že sestavení je výchozí cíl.

   /v:d Přepínač určuje podrobný popis procesu vytváření.

   Mají být zobrazeny tyto řádky:

   Skipping target "Build" because all output files are up-to-date with respect to the input files.

   Input files: HelloWorld.cs

   Output files: Bin\MSBuildSample.exe

   MSBuild vynechává sestavení cílového protože žádné zdrojové soubory změněn byla poslední vytvořena.

Příklad

Description

Následující příklad ukazuje soubor projektu, který se kompiluje Visual C# aplikace a zaznamená zprávu, která obsahuje název výstupního souboru.

Kód

<Project DefaultTargets = "Compile"
    xmlns="https://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

Description

Následující příklad ukazuje soubor projektu, který se kompiluje Visual Basic aplikace a zaznamená zprávu, která obsahuje název výstupního souboru.

Kód

<Project DefaultTargets = "Compile"
    xmlns="https://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 je další?

Visual Studio automaticky provést práci, které je uvedeno v tomto návodu.Informace o tom, jak vytvořit, upravit, vytvořit a otestovat MSBuild souborů projektu pomocí aplikace Visual Studio, viz Názorný postup: Pomocí nástroje MSBuild.

Viz také

Další zdroje

MSBuild

Nástroj MSBuild odkaz