Wskazówki: tworzenie pliku projektu MSBuild od zera

Artykuł
06/10/2015

Języki programowania, które dla środowiska .NET Framework używa plików projektu MSBuild do opisywania i kontroluje procesu tworzenia aplikacji.Gdy używasz programu Visual Studio do tworzenia pliku projektu programu MSBuild, właściwy XML jest automatycznie dodawany do pliku.Jednak może okazać się pomocne w zrozumieniu, w jaki sposób XML jest zorganizowany i jak można go zmienić, aby kontrolować kompilację.

Aby uzyskać informacje na temat tworzenia pliku projektu dla projektów C++, zobacz MSBuild (Visual C++).

W tym instruktażu przedstawiono sposób przyrostowego tworzenia pliku projektu podstawowego, za pomocą edytora tekstu.Instruktaż przebiega w następujący sposób:

Utwórz minimalny plik źródłowy aplikacji.
Utwórz minimalny plik projektu MSBuild.
Rozszerz zmienną środowiskową PATH, aby uwzględnić MSBuild.
Kompiluj aplikację przy użyciu pliku projektu.
Dodaj właściwości do kontrolowania kompilacji.
Steruj kompilacją przez zmianę wartości właściwości.
Dodaj cele, które mają być poddane kompilacji.
Steruj kompilacją przez określenie obiektów docelowych.
Kompiluj przyrostowo.

W tym instruktażu przedstawiono sposób budowania projektu w wierszu polecenia i przeglądania wyników.Aby uzyskać więcej informacji na temat MSBuild i sposobie uruchomienia MSBuild w wierszu polecenia, zobacz Wskazówki: używanie programu MSBuild.

Aby ukończyć Instruktaż, musisz mieć zainstalowany .NET Framework (wersja 2.0, 3.5, 4.0 lub 4.5), ponieważ zawiera on MSBuild i kompilator Visual C#, które są wymagane do instruktażu.

Tworzenie minimalnej aplikacji

W tej części przedstawiono sposób tworzenia minimalne Visual C# aplikacji plik źródłowy przy użyciu tekstu edytora.

Aby utworzyć minimalną aplikację

W wierszu polecenia przejdź do folderu, w którym chcesz utworzyć aplikację, na przykład \My Documents\ lub \Desktop\.
Wpisz md HelloWorld ,aby utworzyć podfolder o nazwie \HelloWorld\.
Wpisz cd HelloWorld aby zmienić do nowego folderu.

Otwórz Notatnik lub inny edytor tekstu i następnie skopiuj następujący kod.

using System;

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

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

Zapisz ten plik źródłowy kodu i nadaj mu nazwę Helloworld.csproj.
Kompiluj aplikację wpisując csc helloworld.cs w wierszu polecenia.
Przetestuj aplikację wpisując helloworld w wierszu polecenia.

Hello, world! komunikat o błędzie powinien być wyświetlony.
Usuń aplikację wpisując del helloworld.exe w wierszu polecenia.

Tworzenie minimalnego pliku projektu MSBuild

Teraz, gdy posiadasz minimalny plik źródłowy aplikacji, można utworzyć minimalny plik projektu w celu kompilacji aplikacji.Ten plik projektu zawiera następujące elementy:

Wymagany katalog główny Project węzła.
Węzeł ItemGroup zawiera elementy jednostki.
Element jednostki odwołujący się do pliku źródłowego aplikacji.
Węzeł Target zawiera zadania, które są wymagane do kompilowania aplikacji.
Element Task, aby uruchomić kompilator Visual C# do kompilowania aplikacji.

Aby utworzyć plik projektu minimalnego MSBuild

W edytorze tekstów należy zastąpić istniejący tekst za pomocą tych dwóch linijek:
```
<Project xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
</Project>
```
Wstaw ten węzeł ItemGroup jako element podrzędny węzła Project:
```
  <ItemGroup>
    <Compile Include="helloworld.cs" />
  </ItemGroup>
```
Należy zauważyć, że ItemGroup zawiera już element pozycji.
Dodaj węzeł Target jako element podrzędny węzła Project.Nazwij węzeł Kompilacja.
```
  <Target Name="Build">
  </Target>
```
Wstaw ten element zadania jako element podrzędny węzła Target:
```
    <Csc Sources="@(Compile)"/>
```
Zapisz ten plik projektu i nadaj mu nazwę Helloworld.csproj.

Plik projektu minimalnego powinien przypominać następujący kod:

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

Zadania w systemie docelowym kompilacji są wykonywane sekwencyjnie.W tym przypadku zadanie kompilatora Visual C# Csc jest jedynym zadaniem.Oczekuje listy plików źródłowych do kompilowania i jest określony przez wartość elementu Compile.Compile Element odwołuje się tylko do jednego pliku źródłowego Helloworld.cs.

[!UWAGA]

W pozycji elementu, można użyć symbolu wieloznacznego gwiazdki (*), aby odwołać wszystkie pliki, które mają rozszerzenie nazwy pliku .cs, w następujący sposób:

<Compile Include="*.cs" />

Jednak nie zaleca się stosowania symboli wieloznacznych, ponieważ sprawiają, że debugowanie i selektywne ukierunkowanie jest trudniejsze, jeżeli pliki źródłowe są dodawane lub usuwane.

Rozszerzanie ścieżki, aby uwzględnić MSBuild

Aby uzyskać dostęp do programu MSBuild, należy rozszerzyć zmiennej środowiskowej PATH, aby dołączyć folder programu .NET Framework.

Aby dodać MSBuild do ścieżki

Trwa uruchamianie w programie Visual Studio 2013, można znaleźć MSBuild.exe w folderze MSBuild (%ProgramFiles%\MSBuild w 32-bitowym systemie operacyjnym, lub %ProgramFiles(x86)%\MSBuild w 64-bitowym systemie operacyjnym).

W wierszu polecenia wpisz polecenie set PATH=%PATH%;%ProgramFiles%\MSBuild lub set PATH=%PATH%;%ProgramFiles(x86)%\MSBuild.

Alternatywnie, jeśli zainstalowano Visual Studio, można użyć Wiersza polecenia programu Visual Studio, który zawiera ścieżkę zawierającą folder programu MSBuild.

Używanie pliku projektu do kompilacji aplikacji

Teraz, aby skompilować aplikację, należy użyć pliku projektu, który został właśnie utworzony.

Aby skompilować aplikację

W wierszu poleceń wpisz msbuild helloworld.csproj /t:Build.

To skompiluje Kompilację docelową projektu Helloworld wywołując kompilator Visual C# do tworzenia aplikacji Helloworld.
Przetestuj aplikację wpisując helloworld.

Hello, world! komunikat o błędzie powinien być wyświetlony.

[!UWAGA]

Można zobaczyć więcej szczegółów na temat kompilacji, zwiększając poziom szczegółowości.Aby ustawić poziom szczegółowości "szczegółowe", należy wpisać jedno z tych poleceń w wierszu polecenia:

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

Dodawanie właściwości kompilacji

Można dodać właściwości kompilacji do pliku projektu, aby dalej kontrolować kompilację.Teraz dodaj następujące właściwości:

Właściwość AssemblyName do określenia nazwy aplikacji.
Właściwość OutputPath do określenia folderu zawierającego aplikację.

Aby dodać właściwości kompilacji

Usuń istniejącą aplikację wpisując del helloworld.exe w wierszu polecenia.

W pliku projektu, wstaw element PropertyGroup tuż po otwarciu elementu Project:

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

Dodaj to zadanie do docelowej kompilacji tuż przed zadaniem Csc:
```
    <MakeDir Directories="$(OutputPath)"      Condition="!Exists('$(OutputPath)')" />
```
MakeDir zadanie tworzy folder o nazwie OutputPath właściwości, pod warunkiem że żaden folder o tej nazwie obecnie nie istnieje.
Dodaj ten atrybut OutputAssembly do zadania Csc:
```
<Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
```
To powoduje, że kompilator programu Visual Studio C# produkuje zestawu o nazwie AssemblyName właściwość i umieść go w folderze o nazwie OutputPath właściwości.
Zapisz zmiany.

Plik projektu minimalnego powinien teraz przypominać następujący kod:

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

[!UWAGA]

Zaleca się dodać separator ścieżki kreski ułamkowej odwróconej (\) na końcu nazwy folderu w przypadku określenia w OutputPath elementu, zamiast dodawania go w OutputAssembly atrybucie Csc zadania.Dlatego,

<OutputPath>Bin\</OutputPath>

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

jest lepszy niż

<OutputPath>Bin</OutputPath>

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

Testowanie właściwości kompilacji

Teraz można skompilować aplikację przy użyciu pliku projektu, w którym użyto właściwości kompilacji do określenia nazwy folderu danych wyjściowych i aplikacji.

Aby przetestować właściwości kompilacji

W wierszu poleceń wpisz msbuild helloworld.csproj /t:Build.

To tworzy folder \Bin\ folder i następnie wywołuje kompilatora Visual C# do tworzenia aplikacji MSBuildSample i umieszcza go w folderze \Bin\.
Aby sprawdzić, czy folder \Bin\ został utworzony, i czy zawiera aplikację MSBuildSample, należy wpisać dir Bin.
Przetestuj aplikację wpisując Bin\MSBuildSample.

Hello, world! komunikat o błędzie powinien być wyświetlony.

Dodawanie obiektów docelowych kompilacji

Następnie, dodaj jeszcze dwa obiekty docelowe do pliku projektu, w następujący sposób:

Oczyść element docelowy usuwa stare pliki.
Cel odbudowy, który korzysta z DependsOnTargets atrybutu, aby wymusić czystego zadania są uruchamiane przed zadania kompilacji.

Teraz, gdy masz wiele elementów docelowych, można ustawić element docelowy kompilacji jako domyślny element docelowy.

Aby dodać obiekty docelowe kompilacji

W pliku projektu należy dodać dwa obiekty docelowe po docelowej kompilacji:
```
  <Target Name="Clean" >
    <Delete Files="$(OutputPath)$(AssemblyName).exe" />
  </Target>
  <Target Name="Rebuild" DependsOnTargets="Clean;Build" />
```
Czyste miejsce docelowe wywołuje zadanie Usuń do usunięcia aplikacji.Docelowa rekonstrukcji nie jest uruchamiana, dopóki nie uruchomiono zarówno czystego miejsce docelowego i celu kompilacji.Chociaż miejsce docelowe powtórnej kompilacji nie ma zadań, powoduje uruchomienie czyszczenia miejsca docelowego przed jego kompilacją.
Dodaj ten atrybut DefaultTargets do otwarcia elementu Project:
```
<Project DefaultTargets="Build" xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
```
Spowoduje to ustawienie docelowej kompilacji jako domyślnego adresu docelowego.

Plik projektu minimalnego powinien teraz przypominać następujący kod:

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

Testowanie obiektów docelowych kompilacji

Możesz skorzystać z nowych celów kompilacji do badania tych funkcji w pliku projektu:

Kompilowanie domyślnej kompilacji.
Ustawianie nazwy aplikacji w wierszu polecenia.
Usuwanie aplikacji przed kompilacją innej aplikacji.
Usuwanie aplikacji przed bez kompilacji innej aplikacji.

Aby przetestować obiekty docelowe kompilacji

W wierszu poleceń wpisz msbuild helloworld.csproj /p:AssemblyName=Greetings.

Ponieważ nie użyto przełącznika /t do jawnego ustawienia celu, MSBuild uruchamia domyślny element docelowy kompilacji./p przełączanie przesłania AssemblyName właściwość i nadaje jej nową wartość, Pozdrowienia.Powoduje, że nowa aplikację, Greetings.exe, ma być utworzony w folderze \Bin\.
Aby zweryfikować, że folder \Kosz\ zawiera zarówno aplikację MSBuildSample, jak i nową aplikację Greetings, wpisz dir Bin.
Przetestuj aplikację pozdrowienia wpisując Bin\Greetings.

Hello, world! komunikat o błędzie powinien być wyświetlony.
Usuń aplikację MSBuildSample wpisując msbuild helloworld.csproj /t:clean.

To uruchamia zadanie Czysty, aby usunąć aplikację, która ma domyślne AssemblyName wartość właściwości, MSBuildSample.
Usuń aplikację Greetings wpisując msbuild helloworld.csproj /t:clean /p:AssemblyName=Greetings.

To uruchamia zadanie Czysty, aby usunąć aplikację, która ma nadane AssemblyName wartości właściwości, Pozdrowienia.
Aby zweryfikować, że teraz folder jest pusty \Bin\, wpisz dir Bin.
Typ msbuild.

Mimo, że nie określono pliku projektu, MSBuild tworzy pliku helloworld.csproj ponieważ istnieje tylko jeden plik projektu w folderze bieżącym.To powoduje, że nowa aplikacja MSBuildSample ma być utworzona w folderze \Bin\.

Aby sprawdzić, czy folder \Bin\ zawiera aplikację MSBuildSample, należy wpisać dir Bin.

Kompilowanie przyrostowe.

Można kazać programowi MSBuild kompilować obiekt docelowy tylko wtedy, gdy zostały zmienione pliki źródłowe lub pliki docelowe, od których zmiany zależy obiekt docelowego.Program MSBuild używa sygnatury czasowej pliku, aby określić, czy został zmieniony.

Aby kompilować przyrostowo

W pliku projektu należy dodać te atrybuty do otwarcia docelowej kompilacji:
```
Inputs="@(Compile)" Outputs="$(OutputPath)$(AssemblyName).exe"
```
Określa, czy element docelowy kompilacji zależy od plików wejściowych, które są określone w Compile grupy elementów, a dane wyjściowe obiektu docelowego jest pliku aplikacji.

Wynikowa kompilacja docelowa powinna przypominać następujący kod:
```
<Target Name="Build" Inputs="@(Compile)" Outputs="$(OutputPath)$(AssemblyName).exe">
  <MakeDir Directories="$(OutputPath)" Condition="!Exists('$(OutputPath)')" />
  <Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
</Target>
```
Testowanie docelową kompilacji, wpisując msbuild /v:d w wierszu polecenia.

Należy pamiętać, że helloworld.csproj jest domyślnym pliku projektu programu oraz tej kompilacji jest elementem docelowym domyślny.

/v:d przełącznik określa pełny opis procesu tworzenia.

Powinny być wyświetlane następujące wiersze:

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

Program MSBuild pomija obiekt docelowy kompilacji, ponieważ żaden z plików źródłowych nie został zmieniony od czasu ostatniej kompilacji aplikacji.

Przykład

Opis

Poniższy przykład pokazuje plik projektu, który kompiluje aplikację Visual C# i rejestruje wiadomość, która zawiera nazwę pliku wyjściowego.

Kod

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

Przykład

Opis

Poniższy przykład pokazuje plik projektu, który kompiluje aplikację Visual Basic i rejestruje wiadomość, która zawiera nazwę pliku wyjściowego.

Kod

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

Program Visual Studio automatycznie może wykonać wiele pracy, która jest wyświetlana w tym instruktażu.Aby dowiedzieć się, jak użyć programu Visual Studio do tworzenia, edytowania, tworzenia i testowania MSBuild pliki projektu, zobacz Wskazówki: używanie programu MSBuild.

Zobacz też

Inne zasoby

MSBuild

Odwołanie do narzędzia MSBuild

Udostępnij za pośrednictwem

Wskazówki: tworzenie pliku projektu MSBuild od zera

Tworzenie minimalnej aplikacji

Aby utworzyć minimalną aplikację

Tworzenie minimalnego pliku projektu MSBuild

Aby utworzyć plik projektu minimalnego MSBuild

Rozszerzanie ścieżki, aby uwzględnić MSBuild

Aby dodać MSBuild do ścieżki

Używanie pliku projektu do kompilacji aplikacji

Aby skompilować aplikację

Dodawanie właściwości kompilacji

Aby dodać właściwości kompilacji

Testowanie właściwości kompilacji

Aby przetestować właściwości kompilacji

Dodawanie obiektów docelowych kompilacji

Aby dodać obiekty docelowe kompilacji

Testowanie obiektów docelowych kompilacji

Aby przetestować obiekty docelowe kompilacji

Kompilowanie przyrostowe.

Aby kompilować przyrostowo

Przykład

Opis

Kod

Przykład

Opis

Kod

Co dalej?

Zobacz też

Inne zasoby

Dodatkowe zasoby