Erstellen einer MSBuild-Projektdatei von Grund auf neu

Artikel
2025-02-04

Programmiersprachen, die auf .NET Framework abzielen, verwenden MSBuild-Projektdateien, um den Anwendungsbuildprozess zu beschreiben und zu steuern. Wenn Sie Visual Studio zum Erstellen einer MSBuild-Projektdatei verwenden, wird der Datei automatisch die entsprechende XML hinzugefügt. Es könnte jedoch hilfreich für Sie sein zu verstehen, wie XML organisiert ist und wie Sie es ändern können, um den Build-Prozess zu steuern.

Anmerkung

Dieser Artikel eignet sich, wenn Sie die grundlegenden Grundlagen der Funktionsweise von MSBuild unabhängig von jedem SDK erlernen möchten. Das Erstellen mit einem SDK, z. B. wenn Sie dotnet build verwenden oder das Sdk Attribut zum Stammprojektelement hinzufügen, wird in diesem Artikel nicht behandelt. Siehe .NET Project SDKs.

Die von standard .csproj Dateien importierte Buildlogik unterstützt viele weitere Optionen und einen viel komplexeren Buildprozess als in diesem Beispiel.

Informationen zum Erstellen einer Projektdatei für ein C++-Projekt finden Sie unter MSBuild (C++).

In diesem Lernprogramm wird gezeigt, wie Sie eine einfache Projektdatei inkrementell mithilfe eines Text-Editors erstellen. In der exemplarischen Vorgehensweise werden die nachfolgenden Schritte ausgeführt:

Erweitern Sie die PATH-Umgebungsvariable.
Erstellen Sie eine minimale Anwendungsquelldatei.
Erstellen Sie eine minimale MSBuild-Projektdatei.
Erstellen Sie die Anwendung mithilfe der Projektdatei.
Fügen Sie Eigenschaften hinzu, um den Build zu steuern.
Steuern des Builds durch Ändern von Eigenschaftswerten
Hinzufügen von Zielen zum Build
Steuern Sie den Build, indem Sie Ziele angeben.
Schrittweise aufbauen.

In diesem Tutorial wird gezeigt, wie Sie das Projekt an der Eingabeaufforderung erstellen und die Ergebnisse überprüfen. Weitere Informationen zu MSBuild und zum Ausführen von MSBuild mit der Eingabeaufforderung finden Sie unter Verwenden von MSBuild.

Um das Lernprogramm abzuschließen, müssen Sie Visual Studio installiert haben, da es MSBuild und den C#-Compiler enthält, der für die exemplarische Vorgehensweise erforderlich ist.

Pfad erweitern

Bevor Sie MSBuild verwenden können, müssen Sie die PATH-Umgebungsvariable erweitern, um alle erforderlichen Tools einzuschließen.

Wenn Sie unter Windows arbeiten, verwenden Sie die Entwickler-Eingabeaufforderung für Visual Studio. Suchen Sie im Windows-Suchfeld in der Windows-Taskleiste danach. Um die Umgebung in einer normalen Eingabeaufforderung oder in einer Skriptumgebung einzurichten, führen Sie VSDevCmd.bat im Unterordner Common7/Tools einer Visual Studio-Installation aus.

Erstellen einer minimalen Anwendung

In diesem Abschnitt wird gezeigt, wie Sie mithilfe eines Text-Editors eine minimale C#-Anwendungsquelldatei erstellen.

Navigieren Sie an der Eingabeaufforderung zu dem Ordner, in dem Sie die Anwendung erstellen möchten, z. B. \My Documents\ oder \Desktop\.
Erstellen Sie einen Unterordner mit dem Namen \HelloWorld\, und ändern Sie das Verzeichnis, um darin zu wechseln.

Erstellen Sie in einem Text-Editor eine neue Datei HelloWorld.cs, und kopieren Sie den folgenden Code, und fügen Sie ihn ein:

using System;

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

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

Erstellen Sie die Anwendung, indem Sie csc-helloworld.cs an der Eingabeaufforderung eingeben.
Testen Sie die Anwendung, indem Sie helloworld- an der Eingabeaufforderung eingeben.

Die Hello, world! Meldung sollte angezeigt werden.
Löschen Sie die ausführbare Datei.

Erstellen einer minimalen MSBuild-Projektdatei

Nachdem Sie nun über eine minimale Anwendungsquelldatei verfügen, können Sie eine minimale Projektdatei erstellen, um die Anwendung zu erstellen. Diese Projektdatei enthält die folgenden Elemente:

Der erforderliche Stammknoten Project.
ItemGroup-Knoten mit Elementkomponenten
Ein Element, das auf die Anwendungsquelldatei verweist.
Ein Target Knoten, der Aufgaben enthält, die zum Erstellen der Anwendung erforderlich sind.
Ein Task Element zum Starten des C#-Compilers zum Erstellen der Anwendung.

So erstellen Sie eine minimale MSBuild-Projektdatei

Erstellen Sie im Text-Editor eine neue Datei HelloWorld.fromscratchproj, und geben Sie den folgenden Code ein:
```
<Project>
  <ItemGroup>
    <Compile Include="helloworld.cs" />
  </ItemGroup>
</Project>
```
Diese ItemGroup enthält eine Elementkomponente Compile und gibt eine Quelldatei als Element an.
Fügen Sie einen Target Knoten als untergeordnetes Element des Project Knotens hinzu. Benennen Sie den Knoten Build.
```
<Target Name="Build">
</Target>
```
Fügen Sie dieses Aufgabenelement als untergeordnetes Element des Knotens Target ein.
```
<Csc Sources="@(Compile)"/>
```
Speichern Sie diese Projektdatei, und nennen Sie sie Helloworld.fromscratchproj.

Die minimale Projektdatei sollte dem folgenden Code ähneln:

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

Aufgaben im Build-Ziel werden der Reihe nach ausgeführt. In diesem Fall ist die C#-Compiler-Aufgabe Csc die einzige Aufgabe. Es wird erwartet, dass eine Liste der Quelldateien kompiliert wird, und dies wird durch den Wert des Compile Elements angegeben. Das Compile Element verweist nur auf eine Quelldatei, Helloworld.cs.

Anmerkung

Im Elementelement können Sie das Sternchen Platzhalterzeichen (*) verwenden, um auf alle Dateien mit der Dateinamenerweiterung .cs zu verweisen:

<Compile Include="*.cs" />

Erstellen der Anwendung

Um die Anwendung zu erstellen, verwenden Sie nun die soeben erstellte Projektdatei.

Geben Sie an der Eingabeaufforderung msbuild helloworld.fromscratchproj -t:Build ein.

Dadurch wird das Build-Target der Helloworld-Projektdatei erstellt, indem der C#-Compiler aufgerufen wird, um die Helloworld-Anwendung zu erzeugen.
Testen Sie die Anwendung, indem Sie helloworldeingeben.

Die Hello, world! Meldung sollte angezeigt werden.

Anmerkung

Sie können weitere Details zum Build anzeigen, indem Sie die Ausführlichkeitsstufe erhöhen. Geben Sie diesen Befehl in der Befehlszeile ein, um die Ausführlichkeitsstufe auf "detailliert" festzulegen:

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

Hinzufügen von Buildeigenschaften

Sie können der Projektdatei Buildeigenschaften hinzufügen, um den Build weiter zu steuern. Fügen Sie nun die folgenden Eigenschaften hinzu:

Eine AssemblyName Eigenschaft, um den Namen der Anwendung anzugeben.
Eine OutputPath Eigenschaft, um einen Ordner anzugeben, der die Anwendung enthalten soll.

So fügen Sie Buildeigenschaften hinzu

Löschen Sie die vorhandene ausführbare Anwendung (später fügen Sie ein Clean Ziel zum Löschen alter Ausgabedateien hinzu).

Fügen Sie in der Projektdatei dieses PropertyGroup Element direkt nach dem öffnenden Project-Element ein:

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

Fügen Sie diese Aufgabe zum Build-Target hinzu, direkt vor der Aufgabe Csc.
```
<MakeDir Directories="$(OutputPath)" Condition="!Exists('$(OutputPath)')" />
```
Die MakeDir Aufgabe erstellt einen Ordner, der von der OutputPath-Eigenschaft benannt wird, vorausgesetzt, dass kein Ordner mit diesem Namen vorhanden ist.
Fügen Sie dieses OutputAssembly-Attribut zur aufgabe Csc hinzu:
```
<Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
```
Dadurch wird der C#-Compiler angewiesen, eine Assembly zu erstellen, die von der AssemblyName-Eigenschaft benannt wird, und sie in den Ordner einzufügen, der von der OutputPath-Eigenschaft benannt wird.
Speichern Sie Ihre Änderungen.

Ihre Projektdatei sollte nun dem folgenden Code ähneln:

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

Anmerkung

Es wird empfohlen, den umgekehrten Schrägstrich (\) als Pfadtrennzeichen am Ende des Ordnernamens bei der Angabe im OutputPath-Element anzufügen und nicht im OutputAssembly-Attribut des Csc-Tasks. Daher eignet sich

<OutputPath>Bin\</OutputPath>

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

besser als

<OutputPath>Bin</OutputPath>

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

Testen der Buildeigenschaften

Jetzt können Sie die Anwendung mithilfe der Projektdatei erstellen, in der Sie Buildeigenschaften zum Angeben des Ausgabeordners und des Anwendungsnamens verwendet haben.

Geben Sie an der Eingabeaufforderung msbuild helloworld.fromscratchproj -t:Build ein.

Dadurch wird der Ordner \Bin\ erstellt und anschließend der C#-Compiler aufgerufen, um die MSBuildSample--Anwendung zu erstellen und in den Ordner \Bin\ zu legen.
Um zu überprüfen, ob der ordner \Bin\ erstellt wurde und die MSBuildSample Anwendung enthält, geben Sie Dir Binein.
Testen Sie die Anwendung, indem Sie Bin\MSBuildSample- eingeben, um die ausführbare Datei auszuführen.

Die Hello, world! Meldung sollte angezeigt werden.

Hinzufügen von Buildzielen

Fügen Sie als Nächstes der Projektdatei zwei weitere Ziele hinzu:

Ein sauberes Ziel, das alte Dateien löscht.
Ein Neuerstellungsziel, das das Attribut DependsOnTargets verwendet, um die Ausführung der Clean-Aufgabe vor der Build-Aufgabe zu erzwingen.

Nachdem Sie nun über mehrere Ziele verfügen, können Sie das Build-Target als Standard festlegen.

So fügen Sie Buildziele hinzu

Fügen Sie in der Projektdatei direkt nach dem Buildziel die folgenden beiden Ziele hinzu:
```
<Target Name="Clean" >
  <Delete Files="$(OutputPath)$(AssemblyName).exe" />
</Target>
<Target Name="Rebuild" DependsOnTargets="Clean;Build" />
```
Das Clean-Ziel ruft die Aufgabe "Löschen" auf, um die Anwendung zu löschen. Das Rebuildziel wird erst ausgeführt, nachdem das Cleanziel und das Buildziel ausgeführt wurden. Obwohl das Ziel "Neu erstellen" keine Aufgaben hat, veranlasst es, dass das "Clean"-Ziel vor dem "Build"-Ziel ausgeführt wird.
Fügen Sie dieses DefaultTargets-Attribut zum öffnenden Project-Element hinzu:
```
<Project DefaultTargets="Build">
```
Dadurch wird das Build-Target als Standardziel festgelegt.

Ihre Projektdatei sollte nun dem folgenden Code ähneln:

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

Testen der Buildziele

Sie können die neuen Build-Ziele ausführen, um die Funktionen der Projektdatei zu testen.

Erstellen des Standardbuilds.
Festlegen des Anwendungsnamens an der Eingabeaufforderung
Löschen der Anwendung, bevor eine andere Anwendung erstellt wird.
Löschen der Anwendung, ohne eine andere Anwendung zu erstellen.

So testen Sie die Buildziele

Geben Sie an der Eingabeaufforderung msbuild helloworld.fromscratchproj -p:AssemblyName=Greetings ein.

Da Sie den -t- Switch nicht verwendet haben, um das Ziel explizit festzulegen, führt MSBuild das Standardbuildziel aus. Die -p- Switch setzt die AssemblyName-Eigenschaft außer Kraft und gibt ihr den neuen Wert Greetings. Dies bewirkt, dass eine neue Anwendung, Greetings.exe, im Ordner \Bin\ erstellt wird.
Um zu überprüfen, ob der Ordner \Bin\ sowohl die MSBuildSample Anwendung als auch die neue Greetings Anwendung enthält, geben Sie Dir Binein.
Testen Sie die Begrüßungsanwendung (z. B. durch Eingabe Bin\Greetings unter Windows).

Die Hello, world! Meldung sollte angezeigt werden.
Löschen Sie die MSBuildSample-Anwendung, indem Sie msbuild helloworld.fromscratchproj -t:cleaneingeben.

Dadurch wird der Cleantask ausgeführt, um die Anwendung mit dem AssemblyName-Standardeigenschaftswert MSBuildSample zu entfernen.
Löschen Sie die Greetings-Anwendung, indem Sie msbuild helloworld.fromscratchproj -t:clean -p:AssemblyName=Greetingseingeben.

Dadurch wird der Cleantask ausgeführt, um die Anwendung mit dem angegebenen AssemblyName-Eigenschaftswert Greetings zu entfernen.
Um zu überprüfen, ob der ordner \Bin\ jetzt leer ist, geben Sie Dir Binein.
Geben Sie msbuild ein.

Obwohl keine Projektdatei angegeben ist, erstellt MSBuild die helloworld.fromscratchproj Datei, da nur eine Projektdatei im aktuellen Ordner vorhanden ist. Dies bewirkt, dass die MSBuildSample- Anwendung im Ordner \Bin\ erstellt wird.

Um zu überprüfen, ob der ordner \Bin\ die MSBuildSample Anwendung enthält, geben Sie dir Binein.

Schrittweiser Aufbau

Sie können MSBuild anweisen, ein Ziel nur zu erstellen, wenn sich die Quelldateien oder Zieldateien, von denen das Ziel abhängt, geändert haben. MSBuild verwendet den Zeitstempel einer Datei, um zu bestimmen, ob sie geändert wurde.

Inkrementell aufbauen

Fügen Sie in der Projektdatei dem ersten Buildziel die folgenden Attribute hinzu:

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

Dadurch wird angegeben, dass das Buildziel von den Eingabedateien abhängt, die in der Compile Elementgruppe angegeben sind und dass das Ausgabeziel die Anwendungsdatei ist.

Das resultierende Buildziel sollte dem folgenden Code ähneln:

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

Testen Sie das Build-Target, indem Sie an der Eingabeaufforderung msbuild -v:d eingeben.

Denken Sie daran, dass helloworld.fromscratchproj die Standardprojektdatei ist und build das Standardziel ist.

Der Parameter -v:d ist eine Abkürzung von -verbosity:detailed, was Sie zuvor verwendet haben.

Wenn Sie die Ausgabe bereits erstellt haben, sollten diese Zeilen angezeigt werden:

Das Ziel „Build“ wird übersprungen, da alle Ausgabedateien hinsichtlich der Eingabedateien aktuell sind.

MSBuild überspringt das Buildziel, da sich keine der Quelldateien seit der letzten Erstellung der Anwendung geändert hat.

C#-Beispiel

Das folgende Beispiel zeigt eine Projektdatei, die eine C#-Anwendung kompiliert und eine Meldung protokolliert, die den Namen der Ausgabedatei enthält.

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

Das folgende Beispiel zeigt eine Projektdatei, die eine Visual Basic-Anwendung kompiliert und eine Meldung protokolliert, die den Namen der Ausgabedatei enthält.

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>

Was kommt als nächstes?

Visual Studio kann automatisch einen Großteil der in dieser exemplarischen Vorgehensweise gezeigten Arbeit ausführen. Informationen zum Erzeugen, Bearbeiten, Erstellen und Testen von MSBuild-Projektdateien mithilfe von Visual Studio finden Sie unter Verwendung von MSBuild.

Freigeben über

Erstellen einer MSBuild-Projektdatei von Grund auf neu

Pfad erweitern

Erstellen einer minimalen Anwendung

Erstellen einer minimalen MSBuild-Projektdatei

So erstellen Sie eine minimale MSBuild-Projektdatei

Erstellen der Anwendung

Hinzufügen von Buildeigenschaften

So fügen Sie Buildeigenschaften hinzu

Testen der Buildeigenschaften

Hinzufügen von Buildzielen

So fügen Sie Buildziele hinzu

Testen der Buildziele

So testen Sie die Buildziele

Schrittweiser Aufbau

Inkrementell aufbauen

C#-Beispiel

Code

Visual Basic-Beispiel

Code

Was kommt als nächstes?

Verwandte Inhalte

Feedback

Zusätzliche Ressourcen