Een volledig nieuw MSBuild-projectbestand maken

Artikel
01/26/2025

Programmeertalen die gericht zijn op .NET Framework gebruiken MSBuild-projectbestanden om het buildproces van de toepassing te beschrijven en te beheren. Wanneer u Visual Studio gebruikt om een MSBuild-projectbestand te maken, wordt de juiste XML automatisch aan het bestand toegevoegd. Het kan echter handig zijn om te begrijpen hoe de XML is georganiseerd en hoe u deze kunt wijzigen om een build te beheren.

Notitie

Dit artikel is geschikt als u de basisprincipes wilt leren van hoe MSBuild onafhankelijk van een SDK werkt. Bouwen met een SDK, bijvoorbeeld wanneer u dotnet build gebruikt of het kenmerk Sdk toevoegt aan het hoofdprojectelement, wordt niet behandeld in dit artikel. Zie SDK's voor .NET-projecten.

De buildlogica die wordt geïmporteerd door standaardbestanden .csproj ondersteunt veel meer opties en een veel complexer buildproces dan in dit voorbeeld.

Zie MSBuild (C++)voor informatie over het maken van een projectbestand voor een C++-project.

In deze zelfstudie ziet u hoe u stapsgewijs een basisprojectbestand maakt met behulp van alleen een teksteditor. De procedure voert de volgende stappen uit:

Breid de omgevingsvariabele PATH uit.
Maak een minimaal toepassingsbronbestand.
Maak een minimaal MSBuild-projectbestand.
Bouw de toepassing met behulp van het projectbestand.
Voeg eigenschappen toe om de build te beheren.
Beheer de opbouw door eigenschapswaarden te wijzigen.
Voeg doelen toe aan de build.
Bepaal de build door doelen op te geven.
Bouw stapsgewijs.

In deze zelfstudie ziet u hoe u het project bouwt bij de opdrachtprompt en de resultaten bekijkt. Zie MSBuildgebruiken voor meer informatie over MSBuild en hoe u MSBuild uitvoert bij de opdrachtprompt.

Als u de zelfstudie wilt voltooien, moet Visual Studio zijn geïnstalleerd omdat het MSBuild en de C#-compiler bevat, die vereist zijn voor het scenario.

Het pad uitbreiden

Voordat u MSBuild kunt gebruiken, moet u de omgevingsvariabele PATH uitbreiden om alle vereiste hulpprogramma's op te nemen.

Als u windows gebruikt, kunt u de opdrachtprompt Developer voor Visual Studiogebruiken. Zoek ernaar in het zoekvak van Windows op de Windows-taakbalk. Als u de omgeving wilt instellen in een gewone opdrachtprompt of in een scriptomgeving, voert u VSDevCmd.bat uit in de submap Common7/Tools van een Visual Studio-installatie.

Een minimale toepassing maken

In deze sectie ziet u hoe u een minimaal C#-toepassingsbronbestand maakt met behulp van een teksteditor.

Blader bij de opdrachtprompt naar de map waarin u de toepassing wilt maken, bijvoorbeeld \Mijn documenten\ of \Desktop\.
Maak een submap met de naam \HelloWorld\ en wijzig de map om erin te gaan.

Maak in een teksteditor een nieuw bestand HelloWorld.cs en kopieer en plak de volgende code:

using System;

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

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

Bouw de toepassing door csc-helloworld.cs te typen bij de opdrachtprompt.
Test de toepassing door helloworld- te typen bij de opdrachtprompt.

De Hallo, wereld! bericht moet worden weergegeven.
Verwijder het uitvoerbare bestand.

Een minimaal MSBuild-projectbestand maken

Nu u een minimaal toepassingsbronbestand hebt, kunt u een minimaal projectbestand maken om de toepassing te bouwen. Dit projectbestand bevat de volgende elementen:

Het vereiste hoofdknooppunt Project.
Een ItemGroup knooppunt dat itemelementen bevat.
Een itemelement dat verwijst naar het bronbestand van de toepassing.
Een Target knooppunt dat taken bevat die nodig zijn om de toepassing te bouwen.
Een Task-element om de C#-compiler te starten om de toepassing te bouwen.

Een minimaal MSBuild-projectbestand maken

Maak in de teksteditor een nieuw bestand HelloWorld.fromscratchproj en voer de volgende code in:
```
<Project>
  <ItemGroup>
    <Compile Include="helloworld.cs" />
  </ItemGroup>
</Project>
```
Deze ItemGroup bevat een itemelement Compile en geeft één bronbestand op als item.
Voeg een Target-knooppunt toe als onderliggend element van het Project-knooppunt. Geef het knooppunt een naam Build.
```
<Target Name="Build">
</Target>
```
Voeg dit taakelement in als een onderliggend element van het knooppunt Target:
```
<Csc Sources="@(Compile)"/>
```
Sla dit projectbestand op en noem het Helloworld.fromscratchproj.

Het minimale projectbestand moet er ongeveer uitzien als de volgende code:

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

De taken in de buildtarget worden opeenvolgend uitgevoerd. In dit geval is de C#-compiler Csc taak de enige taak. Er wordt een lijst met bronbestanden verwacht die moeten worden gecompileerd en dit wordt gegeven door de waarde van het Compile item. Het Compile item verwijst naar slechts één bronbestand, Helloworld.cs.

Notitie

In het itemelement kunt u het jokerteken (*) van het sterretje (*) gebruiken om als volgt te verwijzen naar alle bestanden met de bestandsextensie .cs:

<Compile Include="*.cs" />

De toepassing bouwen

Als u de toepassing wilt bouwen, gebruikt u het projectbestand dat u zojuist hebt gemaakt.

Typ bij de opdrachtprompt msbuild helloworld.fromscratchproj -t:Build.

Hiermee wordt het builddoel van het Helloworld-projectbestand gebouwd door de C#-compiler aan te roepen om de Helloworld-toepassing te maken.
Test de toepassing door helloworld-te typen.

De Hallo, wereld! bericht moet worden weergegeven.

Notitie

U kunt meer informatie over de build bekijken door het uitgebreidheidsniveau te verhogen. Als u het uitgebreidheidsniveau wilt instellen op 'gedetailleerd', typt u deze opdracht bij de opdrachtprompt:

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

Build-eigenschappen toevoegen

U kunt build-eigenschappen toevoegen aan het projectbestand om de build verder te beheren. Voeg nu deze eigenschappen toe:

Een AssemblyName eigenschap om de naam van de toepassing op te geven.
Een OutputPath eigenschap om een map op te geven die de toepassing bevat.

Om build-eigenschappen toe te voegen

Verwijder het uitvoerbare bestand van de bestaande toepassing (later voegt u een Clean doel toe om het verwijderen van oude uitvoerbestanden af te handelen).

Voeg in het projectbestand dit PropertyGroup element in vlak na het openen Project element:

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

Voeg deze taak toe aan het builddoel, net vóór de Csc taak:
```
<MakeDir Directories="$(OutputPath)" Condition="!Exists('$(OutputPath)')" />
```
De MakeDir taak maakt een map met de naam van de eigenschap OutputPath, mits er momenteel geen map met die naam bestaat.
Voeg dit OutputAssembly kenmerk toe aan de Csc taak:
```
<Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
```
Hiermee geeft u de C#-compiler de opdracht om een assembly te produceren met de naam van de eigenschap AssemblyName en deze in de map te plaatsen die wordt genoemd door de eigenschap OutputPath.
Sla uw wijzigingen op.

Het projectbestand moet nu lijken op de volgende code:

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

Notitie

U wordt aangeraden het padscheidingsteken (\) toe te voegen aan het einde van de mapnaam wanneer u het opgeeft in het OutputPath element, in plaats van het toe te voegen aan het kenmerk OutputAssembly van de Csc taak. Daarom

<OutputPath>Bin\</OutputPath>

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

is beter dan

<OutputPath>Bin</OutputPath>

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

De build-eigenschappen testen

U kunt nu de toepassing bouwen met behulp van het projectbestand waarin u build-eigenschappen hebt gebruikt om de uitvoermap en toepassingsnaam op te geven.

Typ bij de opdrachtprompt msbuild helloworld.fromscratchproj -t:Build.

Hiermee maakt u de map \Bin\ en roept u vervolgens de C#-compiler aan om de MSBuildSample-toepassing te maken en deze in de map \Bin\ te plaatsen.
Als u wilt controleren of de map \Bin\ is gemaakt en of deze de MSBuildSample-toepassing bevat, typt u dir Bin-.
Test de toepassing door Bin\MSBuildSample- te typen om het uitvoerbare bestand uit te voeren.

De Hallo, wereld! bericht moet worden weergegeven.

Builddoelen toevoegen

Voeg vervolgens als volgt twee doelen toe aan het projectbestand:

Een opgeschoond doel waarmee oude bestanden worden verwijderd.
Een herbouwdoel dat gebruikmaakt van het kenmerk DependsOnTargets om de taak Opschonen af te dwingen voordat de build-taak wordt uitgevoerd.

Nu u meerdere doelen hebt, kunt u het builddoel instellen als het standaarddoel.

Builddoelen toevoegen

Voeg in het projectbestand deze twee doelen toe vlak na het builddoel:
```
<Target Name="Clean" >
  <Delete Files="$(OutputPath)$(AssemblyName).exe" />
</Target>
<Target Name="Rebuild" DependsOnTargets="Clean;Build" />
```
Met het doel Opschonen wordt de taak Verwijderen aangeroepen om de toepassing te verwijderen. Het doel Herbouwen wordt pas uitgevoerd als zowel het clean-doel als het build-doel zijn uitgevoerd. Hoewel het doel Opnieuw opbouwen geen taken heeft, zorgt het ervoor dat het doel Opschonen wordt uitgevoerd vóór het doel Opbouwen.
Voeg dit DefaultTargets-kenmerk toe aan het openings-element Project.
```
<Project DefaultTargets="Build">
```
Hiermee stelt u het builddoel in als het standaarddoel.

Het projectbestand moet nu lijken op de volgende code:

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

De builddoelen testen

U kunt de nieuwe builddoelen gebruiken om deze functies van het projectbestand te testen:

De standaardbuild bouwen.
De naam van de toepassing instellen bij de opdrachtprompt.
De toepassing verwijderen voordat een andere toepassing wordt gebouwd.
De toepassing verwijderen zonder een andere toepassing te bouwen.

Het testen van de builddoelen

Typ bij de opdrachtprompt de opdracht msbuild helloworld.fromscratchproj -p:AssemblyName=Greetings.

Omdat u de -t-switch niet hebt gebruikt om het doel expliciet in te stellen, voert MSBuild het standaard builddoel uit. De -p overschrijft de eigenschap AssemblyName en geeft deze de nieuwe waarde, Greetings. Hierdoor wordt een nieuwe toepassing, Greetings.exe, gemaakt in de map \Bin\.
Als u wilt controleren of de map \Bin\ zowel de toepassing MSBuildSample als de nieuwe toepassing Greetings bevat, typt u dir Bin.
Test de toepassing Begroetingen (bijvoorbeeld door Bin\Greetings in Windows te typen).

De Hallo, wereld! bericht moet worden weergegeven.
Verwijder de MSBuildSample-toepassing door te typen: msbuild helloworld.fromscratchproj -t:clean.

Hiermee wordt de taak Opschonen uitgevoerd om de toepassing met de standaardwaarde van de eigenschap AssemblyName te verwijderen, MSBuildSample.
Verwijder de toepassing Greetings door msbuild helloworld.fromscratchproj -t:clean -p:AssemblyName=Greetingste typen.

Hiermee wordt de taak Opschonen uitgevoerd om de toepassing met de opgegeven eigenschapswaarde AssemblyName te verwijderen, Greetings.
Als u wilt controleren of de map \Bin\ nu leeg is, typt u dir Bin.
Typ msbuild.

Hoewel er geen projectbestand is opgegeven, bouwt MSBuild het helloworld.fromscratchproj bestand omdat er slechts één projectbestand in de huidige map staat. Hierdoor wordt de MSBuildSample--toepassing gemaakt in de map \Bin\.

Als u wilt controleren of de map \Bin\ de MSBuildSample-toepassing bevat, typt u dir Bin-.

Incrementeel bouwen

U kunt MSBuild vertellen een doel alleen te bouwen als de bronbestanden of doelbestanden waarvoor het doel afhankelijk is, zijn gewijzigd. MSBuild gebruikt het tijdstempel van een bestand om te bepalen of het is gewijzigd.

Incrementeel bouwen

Voeg in het projectbestand deze kenmerken toe aan het openingsdoel build:

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

Hiermee geeft u op dat het builddoel afhankelijk is van de invoerbestanden die zijn opgegeven in de Compile itemgroep en dat het uitvoerdoel het toepassingsbestand is.

Het resulterende builddoel moet er ongeveer uitzien als de volgende code:

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

Test het builddoel door msbuild -v:d te typen bij de opdrachtprompt.

Houd er rekening mee dat helloworld.fromscratchproj het standaardprojectbestand is en dat Build het standaarddoel is.

De -v:d switch is een afkorting van -verbosity:gedetailleerd die u eerder hebt gebruikt.

Als u de uitvoer al hebt gemaakt, moeten deze regels worden weergegeven:

Doel "Build" overslaan omdat alle uitvoerbestanden up-toactueel zijn in vergelijking met de invoerbestanden.

MSBuild slaat het builddoel over omdat geen van de bronbestanden zijn gewijzigd sinds de toepassing voor het laatst is gebouwd.

C#-voorbeeld

In het volgende voorbeeld ziet u een projectbestand dat een C#-toepassing compileert en een bericht registreert dat de naam van het uitvoerbestand bevat.

Code

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

In het volgende voorbeeld ziet u een projectbestand dat een Visual Basic-toepassing compileert en een bericht registreert dat de naam van het uitvoerbestand bevat.

Code

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

Wat is de volgende stap?

Visual Studio kan automatisch veel van het werk doen dat in dit scenario wordt weergegeven. Zie MSBuild-gebruiken voor meer informatie over het gebruik van Visual Studio voor het maken, bewerken, bouwen en testen van MSBuild-projectbestanden.

Overzicht van MSBuild
MSBuild-verwijzing

Delen via

Een volledig nieuw MSBuild-projectbestand maken

Het pad uitbreiden

Een minimale toepassing maken

Een minimaal MSBuild-projectbestand maken

Een minimaal MSBuild-projectbestand maken

De toepassing bouwen

Build-eigenschappen toevoegen

Om build-eigenschappen toe te voegen

De build-eigenschappen testen

Builddoelen toevoegen

Builddoelen toevoegen

De builddoelen testen

Het testen van de builddoelen

Incrementeel bouwen

Incrementeel bouwen

C#-voorbeeld

Code

Visual Basic-voorbeeld

Code

Wat is de volgende stap?

Feedback

Aanvullende resources

Delen via

Een volledig nieuw MSBuild-projectbestand maken

Het pad uitbreiden

Een minimale toepassing maken

Een minimaal MSBuild-projectbestand maken

Een minimaal MSBuild-projectbestand maken

De toepassing bouwen

Build-eigenschappen toevoegen

Om build-eigenschappen toe te voegen

De build-eigenschappen testen

Builddoelen toevoegen

Builddoelen toevoegen

De builddoelen testen

Het testen van de builddoelen

Incrementeel bouwen

Incrementeel bouwen

C#-voorbeeld

Code

Visual Basic-voorbeeld

Code

Wat is de volgende stap?

Verwante inhoud

Feedback

Aanvullende resources