Skapa en MSBuild-projektfil från grunden

2025-01-27

Programmeringsspråk som är avsedda för .NET Framework använder MSBuild-projektfiler för att beskriva och styra programbyggprocessen. När du använder Visual Studio för att skapa en MSBuild-projektfil läggs lämplig XML till i filen automatiskt. Det kan dock vara bra att förstå hur XML-koden är ordnad och hur du kan ändra den för att styra en version.

Not

Den här artikeln är lämplig om du vill lära dig grunderna i hur MSBuild fungerar oberoende av någon SDK. Att skapa med ett SDK, till exempel när du använder dotnet build eller om du lägger till attributet Sdk i rotprojektelementet, beskrivs inte i den här artikeln. Se .NET Project SDK:er.

Bygglogik som importeras av standardfiler .csproj stöder många fler alternativ och en mycket mer komplex byggprocess än i det här exemplet.

Information om hur du skapar en projektfil för ett C++-projekt finns i MSBuild (C++).

Den här självstudien visar hur du skapar en grundläggande projektfil stegvis med hjälp av endast en textredigerare. Genomgången följer dessa steg:

Utöka PATH-miljövariabeln.
Skapa en minimal programkällafil.
Skapa en minimal MSBuild-projektfil.
Skapa programmet med hjälp av projektfilen.
Lägg till egenskaper för att styra bygget.
Kontrollera bygget genom att ändra egenskapsvärden.
Lägg till mål i bygget.
Kontrollera bygget genom att ange mål.
Skapa stegvis.

Denna handledning visar hur du bygger projektet på kommandoraden och analyserar resultaten. Mer information om MSBuild och hur du kör MSBuild i kommandotolken finns i Använda MSBuild.

För att slutföra självstudien måste du ha Visual Studio installerat eftersom det innehåller MSBuild och C#-kompilatorn, som krävs för genomgången.

Utöka sökvägen

Innan du kan använda MSBuild måste du utöka path-miljövariabeln så att den innehåller alla nödvändiga verktyg.

Om du kör på Windows kan du använda utvecklarkommandotolken för Visual Studio. Sök efter den i sökrutan i Windows-aktivitetsfältet. Om du vill konfigurera miljön i en vanlig kommandotolk eller i en skriptmiljö kör du VSDevCmd.bat i Common7/Tools undermapp för en Visual Studio-installation.

Skapa ett minimalt program

Det här avsnittet visar hur du skapar en minimal C#-programkällfil med hjälp av en textredigerare.

I kommandotolken bläddrar du till mappen där du vill skapa programmet, till exempel \My Documents\ eller \Desktop\.
Skapa en undermapp med namnet \HelloWorld\ och ändra katalog för att gå in i den.

I en textredigerare skapar du en ny fil HelloWorld.cs och kopierar och klistrar sedan in följande kod:

using System;

class HelloWorld
{
    static void Main()
    {
#if DebugConfig
        Console.WriteLine("WE ARE IN THE DEBUG CONFIGURATION");
#endif

        Console.WriteLine("Hello, world!");
    }
}

Skapa programmet genom att skriva csc-helloworld.cs i kommandotolken.
Testa programmet genom att skriva helloworld- i kommandotolken.

Ett Hello, världen! meddelande ska visas.
Ta bort den körbara filen.

Skapa en minimal MSBuild-projektfil

Nu när du har en minimal programkällafil kan du skapa en minimal projektfil för att skapa programmet. Den här projektfilen innehåller följande element:

Den nödvändiga rotnoden Project.
En ItemGroup nod som ska innehålla objektelement.
Ett objektelement som refererar till programkällans fil.
En Target nod som ska innehålla uppgifter som krävs för att skapa programmet.
Ett Task element för att starta C#-kompilatorn för att skapa programmet.

Skapa en minimal MSBuild-projektfil

I textredigeraren skapar du en ny fil HelloWorld.fromscratchproj och anger följande kod:
```
<Project>
  <ItemGroup>
    <Compile Include="helloworld.cs" />
  </ItemGroup>
</Project>
```
Den här ItemGroup innehåller ett objektelement Compile och anger en källfil som ett objekt.
Lägg till en Target nod som ett underordnat element i nod Project. Ge noden namnet Build.
```
<Target Name="Build">
</Target>
```
Infoga det här aktivitetselementet som ett underordnat element i noden Target:
```
<Csc Sources="@(Compile)"/>
```
Spara den här projektfilen och ge den namnet Helloworld.fromscratchproj.

Din minimala projektfil bör likna följande kod:

<Project>
  <ItemGroup>
    <Compile Include="helloworld.cs"/>
  </ItemGroup>
  <Target Name="Build">
    <Csc Sources="@(Compile)"/>
  </Target>
</Project>

Uppgifter i build-målet körs sekventiellt. I det här fallet är uppgiften med C#-kompilatorn Csc den enda uppgiften. Den förväntar sig att en lista över källfiler kompileras och detta anges av värdet för det Compile objektet. Det Compile objektet refererar bara till en källfil, Helloworld.cs.

Observera

I objektelementet kan du använda jokertecknet asterisk (*) för att referera till alla filer som har filnamnstillägget .cs, enligt följande:

<Compile Include="*.cs" />

Skapa programmet

Om du vill skapa programmet använder du projektfilen som du nyss skapade.

Vid kommandoprompten skriver du msbuild helloworld.fromscratchproj -t:Build.

Detta skapar byggmålet för Helloworld-projektfilen genom att anropa C#-kompilatorn för att skapa Helloworld-programmet.
Testa programmet genom att skriva helloworld.

Det Hello, världen! meddelande ska visas.

Notera

Du kan se mer information om bygget genom att öka verbositetsnivån. Om du vill ange verbositetsnivån till "detaljerad" skriver du det här kommandot i kommandotolken:

msbuild helloworld.fromscratchproj -t:Build -verbosity:detailed

Lägg till byggegenskaper

Du kan lägga till byggegenskaper i projektfilen för att ytterligare kontrollera bygget. Lägg nu till följande egenskaper:

En AssemblyName-egenskap för att ange namnet på programmet.
En OutputPath-egenskap för att ange en mapp som ska innehålla programmet.

Så här lägger du till byggegenskaper

Ta bort det befintliga körbara programmet (senare lägger du till ett Clean mål för att hantera borttagningen av gamla utdatafiler).

I projektfilen infogar du det här PropertyGroup elementet strax efter det inledande Project-elementet:

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

Lägg till den här uppgiften i Build-målet, precis före uppgiften Csc:
```
<MakeDir Directories="$(OutputPath)" Condition="!Exists('$(OutputPath)')" />
```
Den MakeDir-uppgiften skapar en mapp som namnges av egenskapen OutputPath, förutsatt att det för tillfället inte finns någon mapp med det namnet.
Lägg till det här OutputAssembly-attributet i Csc uppgift:
```
<Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
```
Detta instruerar C#-kompilatorn att skapa en sammansättning som namnges av egenskapen AssemblyName och placera den i mappen som heter av egenskapen OutputPath.
Spara ändringarna.

Projektfilen bör nu likna följande kod:

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

Notera

Vi rekommenderar att du lägger till omvänt snedstreck (\) sökvägslimiter i slutet av mappnamnet när du anger det i OutputPath-elementet, i stället för att lägga till det i OutputAssembly-attributet för Csc-aktiviteten. Därför

<OutputPath>Bin\</OutputPath>

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

är bättre än

<OutputPath>Bin</OutputPath>

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

Testa byggegenskaperna

Nu kan du skapa programmet med hjälp av projektfilen där du använde byggegenskaper för att ange utdatamappen och programnamnet.

I kommandotolken skriver du msbuild helloworld.fromscratchproj -t:Build.

Då skapas mappen \Bin\ och anropar sedan C#-kompilatorn för att skapa MSBuildSample-programmet och placerar det i mappen \Bin\.
Om du vill kontrollera att mappen \Bin\ har skapats och att den innehåller MSBuildSample-programmet skriver du dir Bin.
Testa programmet genom att skriva Bin\MSBuildSample för att köra den körbara filen.

Det Hello, världen!-meddelandet ska visas.

Lägga till byggmål

Lägg sedan till ytterligare två mål i projektfilen enligt följande:

Ett rensat mål som tar bort gamla filer.
Ett Rebuild-mål som använder attributet DependsOnTargets för att tvinga aktiviteten Rensa att köras före bygg-aktiviteten.

Nu när du har flera mål kan du ange build-målet som standardmål.

Så här lägger du till byggmål

I projektfilen lägger du till dessa två mål strax efter build-målet:
```
<Target Name="Clean" >
  <Delete Files="$(OutputPath)$(AssemblyName).exe" />
</Target>
<Target Name="Rebuild" DependsOnTargets="Clean;Build" />
```
Målet Rensa anropar uppgiften Ta bort för att radera programmet. Ombyggnadsmålet körs inte förrän både Clean-målet och Build-målet har körts. Även om målet Återskapa inte har några uppgifter, gör det att Clean-målet körs före Build-målet.
Lägg till det här DefaultTargets-attributet i elementet opening Project:
```
<Project DefaultTargets="Build">
```
Detta anger build-målet som standardmål.

Projektfilen bör nu likna följande kod:

<Project DefaultTargets="Build">
  <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>

Testa byggmålen

Du kan använda de nya byggmålen för att testa de här funktionerna i projektfilen:

Skapa standardversionen.
Ange programnamnet i kommandotolken.
Ta bort programmet innan ett annat program skapas.
Ta bort programmet utan att skapa ett annat program.

Testa byggmålen

I kommandotolken skriver du msbuild helloworld.fromscratchproj -p:AssemblyName=Greetings.

Eftersom du inte använde växeln -t för att tydligt specificera byggmålet, kör MSBuild standardmålet Build. Växeln -p åsidosätter egenskapen AssemblyName och ger den det nya värdet Greetings. Detta gör att ett nytt program, Greetings.exe, skapas i mappen \Bin\.
Om du vill kontrollera att mappen \Bin\ innehåller både MSBuildSample-programmet och det nya Greetings-programmet skriver du dir Bin.
Testa programmet Greetings (till exempel genom att skriva Bin\Greetings i Windows).

Det Hello, världen!-meddelandet ska visas.
Ta bort MSBuildSample-programmet genom att skriva msbuild helloworld.fromscratchproj -t:clean.

Då körs Rensa-uppgiften för att ta bort applikationen som har egenskapen MSBuildSamplemed standardvärdet AssemblyName.
Ta bort programmet Greetings genom att skriva msbuild helloworld.fromscratchproj -t:clean -p:AssemblyName=Greetings.

Då körs uppgiften Rensa för att ta bort det program som har angivet AssemblyName egenskapsvärde, Greetings.
Kontrollera att mappen \Bin\ nu är tom genom att skriva dir Bin.
Skriv msbuild.

Även om en projektfil inte har angetts bygger MSBuild helloworld.fromscratchproj fil eftersom det bara finns en projektfil i den aktuella mappen. Detta gör att MSBuildSample-programmet skapas i mappen \Bin\.

Om du vill kontrollera att mappen \Bin\ innehåller MSBuildSample-programmet skriver du dir Bin.

Skapa stegvis

Du kan bara be MSBuild att skapa ett mål om källfilerna eller målfilerna som målet är beroende av har ändrats. MSBuild använder tidsstämpeln för en fil för att avgöra om den har ändrats.

Så här skapar du stegvis

I projektfilen lägger du till de här attributen i det inledande build-målet:

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

Detta anger att build-målet beror på de indatafiler som anges i Compile objektgruppen och att utdatamålet är programfilen.

Det resulterande build-målet bör likna följande kod:

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

Testa build-målet genom att skriva msbuild -v:d i kommandotolken.

Kom ihåg att helloworld.fromscratchproj är standardprojektfilen och att Build är standardmålet.

Växeln -v:d är en förkortning av -verbosity:detailed som du använde tidigare.

Om du redan har skapat utdata bör dessa rader visas:

Hoppar över målet "Build" eftersom alla utdatafiler är up-to-date med avseende på indatafilerna.

MSBuild hoppar över build-målet eftersom ingen av källfilerna har ändrats sedan programmet senast skapades.

C#-exempel

I följande exempel visas en projektfil som kompilerar ett C#-program och loggar ett meddelande som innehåller namnet på utdatafilen.

Kod

<Project DefaultTargets = "Compile">

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

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

    <Target Name="Compile">
        <!-- Run the 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>

Visual Basic-exempel

I följande exempel visas en projektfil som kompilerar ett Visual Basic-program och loggar ett meddelande som innehåller utdatafilens namn.

Kod

<Project DefaultTargets = "Compile">

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

Vad händer härnäst?

Visual Studio kan automatiskt utföra mycket av det arbete som visas i den här genomgången. Mer information om hur du använder Visual Studio för att skapa, redigera, skapa och testa MSBuild-projektfiler finns i Använda MSBuild.

Dela via

Skapa en MSBuild-projektfil från grunden

Utöka sökvägen

Skapa ett minimalt program

Skapa en minimal MSBuild-projektfil

Skapa en minimal MSBuild-projektfil

Skapa programmet

Lägg till byggegenskaper

Så här lägger du till byggegenskaper

Testa byggegenskaperna

Lägga till byggmål

Så här lägger du till byggmål

Testa byggmålen

Testa byggmålen

Skapa stegvis

Så här skapar du stegvis

C#-exempel

Kod

Visual Basic-exempel

Kod

Vad händer härnäst?

Relaterat innehåll

Feedback

Ytterligare resurser