Instruktaż: Tworzenie pliku projektu programu MSBuild od początku

Artykuł
02/27/2013

Języki programowania obiektu docelowego.NET Framework, na przykład Visual C# i Visual Basic MSBuild projektu pliki używane do opisu i kontroli procesu tworzenia aplikacji.Gdy używasz programu Visual Studio do utworzenia pliku projektu programu MSBuild XML właściwe jest automatycznie dodawany do pliku.Jednakże, może się okazać ją zrozumieć, jak zorganizowane są dane XML i w jaki sposób można zmienić go do kontrolowania kompilacji.W tym instruktażu pokazano, jak utworzyć plik projektu podstawowych przyrostowo, za pomocą edytora tekstu.Instruktaż przebiega w następujący sposób:

Utwórz plik źródłowy aplikacji minimal.
Utwórz plik projektu programu MSBuild minimal.
Rozszerzanie zmiennej środowiskowej PATH, aby uwzględnić MSBuild.
Budowanie aplikacji za pomocą pliku projektu.
Dodawanie właściwości do kontrolowania tej kompilacji.
Kompilacja poprzez zmianę wartości właściwości formantu.
Dodawanie obiektów docelowych do kompilacji.
Kompilacja przez określenie celów kontroli.
Budowanie przyrostowo.

W tym instruktażu przedstawiono sposób budowania projektu, w wierszu polecenia i przejrzeć wyniki.Aby uzyskać więcej informacji na temat MSBuild i jak uruchomić program MSBuild w wierszu polecenia, zobacz Instruktaż: Przy użyciu programu MSBuild.

Aby ukończyć instruktażu, musi mieć.NET Framework (w wersji 2.0, 3.5 lub 4.0) zainstalowana, ponieważ zawiera on MSBuild i kompilatora Visual C#, które są wymagane dla Instruktaż.

Tworzenie aplikacji Minimal

W tej sekcji przedstawiono sposób utworzyć minimalne Visual C# źródłowego pliku aplikacji przy użyciu tekstu edytora.

Aby utworzyć aplikację minimal

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

Uruchom Notatnik lub inny edytor tekstów, a następnie wpisz 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 kodu źródłowego i nadaj mu nazwę Helloworld.cs.
Budowanie aplikacji wpisując csc helloworld.cs w wierszu polecenia.
Przetestuj aplikację, wpisując helloworld w wierszu polecenia.

Hello, world! Powinien być wyświetlany komunikat.
Usuń aplikację wpisując del helloworld.exe w wierszu polecenia.

Tworzenie pliku projektu programu MSBuild minimalne

Teraz, że masz plik źródłowy aplikacji minimal, można utworzyć plik projektu minimalne do zbudowania aplikacji.Ten plik projektu zawiera następujące elementy:

Wymagany katalog główny Project węzła.
ItemGroup Węzeł, który ma zawierać element.
Element element, który odnosi się do pliku źródłowego aplikacji.
A Target węzeł, który ma zawierać zadań, które są wymagane do zbudowania aplikacji.
A Task element, aby rozpocząć budowanie aplikacji kompilatora Visual C#.

Aby utworzyć plik projektu programu MSBuild minimalne

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

Plik projektu minimalne powinny przypominają 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 target kompilacji są wykonywane sekwencyjnie.W tym przypadku kompilatora Visual C# Csc zadanie jest zadaniem tylko.Oczekuje, że lista plików źródłowych, aby skompilować i jest określony przez wartość Compile element.Compile Element odwołuje się tylko jeden plik źródłowy, Helloworld.cs.

[!UWAGA]

Znak symbolu wieloznacznego gwiazdki (*) elementu element umożliwia odwołać wszystkie pliki, które mają rozszerzenie nazwy pliku cs, w następujący sposób:

<Compile Include="*.cs" />

Firma Microsoft nie zaleca jednak symboli wieloznacznych, ponieważ ułatwia debugowanie i selektywne ukierunkowanie trudniejsze, jeżeli pliki źródłowe są dodawane lub usuwane.

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

Przed uzyskaniem dostępu MSBuild, należy rozszerzyć zmiennej środowiskowej PATH, aby uwzględnić.NET Framework folderu.

Aby rozszerzyć ścieżki, aby uwzględnić MSBuild

W wierszu polecenia wpisz: set PATH=%PATH%;%WINDIR%\Microsoft.Net\Framework\v4.0.Jeśli masz inną wersję.NET Framework zainstalowana, należy odpowiednio zmienić numer wersji.

[!UWAGA]

Nazwa folderu programu MSBuild na komputerze może zawierać numer kompilacji, takie jak v2.0.50727.Jeśli tak, obejmują numer kompilacji w wierszu polecenia, na przykład, set PATH=%PATH%;%WINDIR%\Microsoft.Net\Framework\v2.0.50727.

Alternatywnie, jeśli masz zainstalowanego Visual Studio, można użyć wiersza polecenia usługi programu Visual Studio, który ma ścieżkę, która zawiera folder programu MSBuild.

Budowanie aplikacji za pomocą pliku projektu

Teraz do zbudowania aplikacji, należy użyć pliku projektu, która została utworzona.

Do zbudowania aplikacji

W wierszu polecenia wpisz: msbuild helloworld.csproj /t:Build.

To z kolei docelowych kompilacji pliku projekt Helloworld wywołując kompilatora Visual C#, aby utworzyć aplikację Helloworld.
Przetestuj aplikację, wpisując helloworld.

Hello, world! Powinien być wyświetlany komunikat.

[!UWAGA]

Widać więcej szczegółów na temat budowania zwiększając poziom szczegółowości.Aby ustawić poziom szczegółowości "detailed", 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 build dalszej kontroli kompilowanie pliku projektu.Teraz dodaj następujące właściwości:

AssemblyName Właściwość, aby określić nazwę aplikacji.
OutputPath Właściwość, aby określić folder zawiera aplikację.

Aby dodać właściwości kompilacji

Usunąć istniejącą aplikację wpisując del helloworld.exe w wierszu polecenia.

W pliku projektu, Wstaw PropertyGroup element zaraz po otwarciu Project element:

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

Dodać to zadanie do docelowej Build tuż przed Csc zadań:
```
    <MakeDir Directories="$(OutputPath)"      Condition="!Exists('$(OutputPath)')" />
```
MakeDir Zadanie tworzy folder o nazwie przez OutputPath właściwość, pod warunkiem, że istnieje obecnie żaden folder o tej nazwie.
Dodaj ten OutputAssembly atrybutu do Csc zadań:
```
<Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
```
To powoduje, że produkują zestawu o nazwie przez kompilator Visual C# AssemblyName właściwości i umieścić go w folderze o nazwie przez OutputPath właściwości.
Zapisz wprowadzone zmiany.

Plik projektu należy teraz przypominają 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ć ogranicznika ścieżki kreski ułamkowej odwróconej (\) na końcu nazwy folderu podczas określania go w OutputPath elementu zamiast dodawania go w OutputAssembly atrybutu Csc zadania.W związku z tym,

<OutputPath>Bin\</OutputPath>

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

jest lepszy niż

<OutputPath>Bin</OutputPath>

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

Badania właściwości kompilacji

Teraz można utworzyć aplikacji przy użyciu pliku projektu używane właściwości build można określić nazwę folderu i stosowanie danych wyjściowych.

Aby przetestować właściwości kompilacji

W wierszu polecenia wpisz: msbuild helloworld.csproj /t:Build.

Ten tworzy \Bin\ folder i następnie wywołuje kompilatora Visual C#, aby utworzyć aplikację MSBuildSample i umieszcza go w folderze \Bin\.
Aby zweryfikować utworzono \Bin\ folder i zawiera aplikację MSBuildSample, należy wpisać dir Bin.
Przetestuj aplikację, wpisując Bin\MSBuildSample.

Hello, world! Powinien być wyświetlany komunikat.

Dodawanie elementów docelowych kompilacji

Następnie dodać dwa więcej obiektów docelowych do pliku projektu w następujący sposób:

Czyste obiektu docelowego, który usuwa stare pliki.
Docelowego Odbuduj, który korzysta z DependsOnTargets atrybutu, aby wymusić czyste zadanie do uruchomienia przed zadania kompilacji.

Teraz, gdy masz wiele elementów docelowych, można ustawić cel budowania jako domyślne miejsce docelowe.

Aby dodać cele kompilacji

W pliku projektu należy dodać tych dwóch celów tuż po docelowych kompilacji:
```
  <Target Name="Clean" >
    <Delete Files="$(OutputPath)$(AssemblyName).exe" />
  </Target>
  <Target Name="Rebuild" DependsOnTargets="Clean;Build" />
```
Czyste docelowych wywołuje usuwanie zadania, aby usunąć aplikację.Docelowe Odbuduj nie działać, dopóki zarówno czyste docelowych i kompilacji został uruchomiony.Chociaż docelowych Odbuduj nie ma żadnych zadań, powoduje, że czyste docelowych do uruchomienia przed docelowych kompilacji.
Dodaj ten DefaultTargets atrybutu do otwarcia Project element:
```
<Project DefaultTargets="Build" xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
```
Spowoduje to ustawienie docelowej kompilacji jako domyślne miejsce docelowe.

Plik projektu należy teraz przypominają 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 cele kompilacji

Można wykonywać nowe cele kompilacji, aby przetestować te funkcje pliku projektu:

Budowanie build domyślne.
Ustawienie nazwy aplikacji, w wierszu polecenia.
Usuwanie aplikacji przed jest wbudowana w innej aplikacji.
Usuwanie aplikacji bez tworzenia innej aplikacji.

Aby przetestować cele kompilacji

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

Ponieważ nie użyto /t Przełącz się do jawnie ustawić cel, MSBuild uruchamia domyślny docelowy kompilacji./p Przełączyć przesłonięcia AssemblyName właściwości i nadaje mu nową wartość Greetings.Powoduje to nową aplikację, Greetings.exe, ma być utworzony w folderze \Bin\.
Aby zweryfikować, że \Bin\ folder zawiera zarówno aplikacji MSBuildSample i Greetings, aplikacja, należy wpisać dir Bin.
Przetestować aplikację Greetings wpisując Bin\Greetings.

Hello, world! Powinien być wyświetlany komunikat.
Usuwanie aplikacji MSBuildSample wpisując msbuild helloworld.csproj /t:clean.

Działa to czyste zadania, aby usunąć aplikację, która ma domyślnie AssemblyName wartość właściwości MSBuildSample.
Usuwanie aplikacji Greetings wpisując msbuild helloworld.csproj /t:clean /p:AssemblyName=Greetings.

Działa to czyste zadania, aby usunąć aplikację, która ma danej AssemblyName wartość właściwości Greetings.
Aby zweryfikować, że \Bin\ folder jest pusty, wpisz dir Bin.
Type msbuild.

Chociaż plik projektu nie jest określony, MSBuild buduje plik helloworld.csproj, ponieważ istnieje tylko jeden plik projektu w bieżącym folderze.To powoduje, że aplikacja MSBuildSample ma być utworzony w folderze \Bin\.

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

Budowanie przyrostowo

Można to stwierdzić MSBuild do tworzenia elementu docelowego, tylko wtedy, gdy zostały zmienione pliki źródłowe lub pliki docelowe zależy od obiektu docelowego.MSBuild używa sygnatura czasowa pliku, aby ustalić, czy została ona zmieniona.

Aby zbudować przyrostowo

W pliku projektu należy dodać te atrybuty do otwarcia docelowej kompilacji:

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

Określa, że docelowy Build zależy od plików wejściowych, które są określone w Compile grupy towarów i że dane wyjściowe obiektem docelowym jest plik aplikacji.

Wynikowy obiekt docelowy kompilacji powinny przypominają 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>

Test docelowych Build wpisując msbuild /v:d w wierszu polecenia.

Należy pamiętać, że helloworld.csproj jest domyślny plik projektu, zbudowany jest domyślny obiekt docelowy.

/v:d Przełącznik określa pełniejszy opis procesu kompilacji.

Te wiersze powinny być wyświetlane:

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 docelowych kompilacji, ponieważ żaden z plików źródłowych nie zmieniły się od czasu stosowania ostatnio został zbudowany.

Przykład

Opis

Poniższy przykład ilustruje plik projektu, który kompiluje Visual C# aplikacji i rejestruje wiadomość, która zawiera nazwy 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 ilustruje plik projektu, który kompiluje Visual Basic aplikacji i rejestruje wiadomość, która zawiera nazwy 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 będzie dalej?

Visual Studio automatycznie można zrobić wiele pracy, który jest wyświetlany w tym instruktażu.Aby dowiedzieć się, jak używać programu Visual Studio do tworzenia, edytowania, zbudować i przetestować pliki projektów programu MSBuild, zobacz Instruktaż: Przy użyciu programu MSBuild.

Zobacz też

Inne zasoby

Program MSBuild

Program MSBuild odniesienia

Udostępnij za pośrednictwem

Instruktaż: Tworzenie pliku projektu programu MSBuild od początku

Tworzenie aplikacji Minimal

Aby utworzyć aplikację minimal

Tworzenie pliku projektu programu MSBuild minimalne

Aby utworzyć plik projektu programu MSBuild minimalne

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

Aby rozszerzyć ścieżki, aby uwzględnić MSBuild

Budowanie aplikacji za pomocą pliku projektu

Do zbudowania aplikacji

Dodawanie właściwości kompilacji

Aby dodać właściwości kompilacji

Badania właściwości kompilacji

Aby przetestować właściwości kompilacji

Dodawanie elementów docelowych kompilacji

Aby dodać cele kompilacji

Testowanie cele kompilacji

Aby przetestować cele kompilacji

Budowanie przyrostowo

Aby zbudować przyrostowo

Przykład

Opis

Kod

Przykład

Opis

Kod

Co będzie dalej?

Zobacz też

Inne zasoby

Dodatkowe zasoby