Freigeben über

MSBuild-Elemente

  • Artikel

MSBuild-Elemente sind Eingaben in das Buildsystem. In der Regel handelt es sich dabei um Dateien (die Dateien sind im Include-Attribut angegeben). Elemente werden auf Grundlage benutzerdefinierter Elementnamen in Elementtypen gruppiert. Elementtypen sind benannte Listen von Elementen, die als Parameter für Aufgaben verwendet werden können. In den Aufgaben werden die Schritte des Buildprozesses mithilfe der Elementwerte ausgeführt.

Da Elemente anhand des Elementtyps benannt werden, zu dem sie gehören, können die Begriffe „Element“ und „Elementwert“ synonym verwendet werden.

Erstellen von Elementen in einer Projektdatei

Elemente werden in der Projektdatei als untergeordnete Elemente eines ItemGroup-Elements deklariert. Gültige Elementnamen beginnen mit einem Groß- oder Kleinbuchstaben oder Unterstrich (_). Gültige nachfolgende Zeichen umfassen alphanumerische Zeichen (Buchstaben oder Ziffern), Unterstrich und Bindestrich (-). Der Name des untergeordneten Elements ist der Typ des Elements. Durch das Include-Attribut des Elements wird angegeben, welche Elemente (Dateien) in den jeweiligen Elementtyp aufgenommen werden sollen. Im folgenden XML wird z.B. der mit Compile benannte Elementtyp erstellt, der zwei Dateien umfasst.

<ItemGroup>
    <Compile Include = "file1.cs"/>
    <Compile Include = "file2.cs"/>
</ItemGroup>

Das Element file2.cs ersetzt das Element file1.cs nicht. Stattdessen wird der Dateiname an die Liste der Werte für den Compile-Elementtyp angefügt.

Das folgende XML erstellt den gleichen Elementtyp, indem beide Dateien in einem Include-Attribut deklariert werden. Achten Sie darauf, dass die Dateinamen durch ein Semikolon voneinander getrennt sind.

<ItemGroup>
    <Compile Include = "file1.cs;file2.cs"/>
</ItemGroup>

Das Include-Attribut ist ein Pfad, der relativ zum Ordner der Projektdatei ($(MSBuildProjectPath)) interpretiert wird. Dies gilt auch dann, wenn sich das Element in einer importierten Datei, wie etwa einer .targets-Datei, befindet.

Erstellen von Elementen während der Ausführung

Elementen außerhalb von Ziel-Elementen werden während der Auswertungsphase eines Builds Werte zugewiesen. Während der anschließenden Ausführungsphase können Elemente wie folgt erstellt oder geändert werden:

  • Jede Aufgabe kann ein Element ausgeben. Das Aufgabe-Element muss über ein untergeordnetes Ausgabe-Element mit einem ItemName-Attribut verfügen, damit ein Element ausgegeben werden kann.

  • Die CreateItem-Aufgabe kann ein Element ausgeben. Diese Verwendung ist veraltet.

  • Target-Elemente enthalten möglicherweise ItemGroup-Elemente, die Item-Elemente enthalten können.

Verweisen auf Elemente in einer Projektdatei

Verwenden Sie die Syntax @(ItemType), um auf Elementtypen in der gesamten Projektdatei zu verweisen. Auf den Elementtyp aus dem vorherigen Beispiel würden Sie z.B. mithilfe von @(Compile) verweisen. Mithilfe dieser Syntax können Sie Elemente an Aufgaben übergeben, indem Sie den Elementtyp als einen Parameter dieser Aufgabe angeben. Weitere Informationen finden Sie unter Vorgehensweise: Auswählen von Dateien für den Buildvorgang.

Standardmäßig sind die Elemente eines Elementtyps durch Semikolons (;) getrennt, wenn er erweitert wird. Sie können die Syntax @(ItemType, 'separator') verwenden, um ein anderes Trennzeichen als das Standardtrennzeichen anzugeben. Weitere Informationen finden Sie unter Vorgehensweise: Anzeigen einer durch Trennzeichen getrennten Elementliste.

Verwenden von Platzhaltern zum Angeben von Elementen

Sie können die Platzhalterzeichen **, * und ? verwenden, um eine Gruppe von Dateien als Eingaben für einen Build anzugeben. So müssen Sie nicht alle Dateien separat auflisten.

  • Das Platzhalterzeichen ? entspricht einem einzelnen Zeichen.
  • Das Platzhalterzeichen * entspricht 0 (null) oder mehr Zeichen.
  • Die Platzhalterzeichenfolge ** entspricht einem partiellen Pfad.

Sie können z.B. alle .cs-Dateien im Verzeichnis der Projektdatei angeben, indem Sie das folgende Element in der Projektdatei verwenden.

<CSFile Include="*.cs"/>

Das folgende Element wählt alle .vb-Dateien auf Laufwerk D: aus:

<VBFile Include="D:/**/*.vb"/>

Wenn Sie literale Zeichen * oder ? in ein Element ohne Platzhaltererweiterung aufnehmen möchten, müssen Sie die Platzhalterzeichen mit Escapezeichen versehen.

Weitere Informationen zu Platzhalterzeichen finden Sie unter Vorgehensweise: Auswählen von Dateien für den Buildvorgang.

Verwenden des Exclude-Attributs

Item-Elemente können das Exclude-Attribut enthalten, das bestimmte Elemente (Dateien) aus dem Elementtyp ausschließt. Das Exclude-Attribut wird normalerweise zusammen mit Platzhalterzeichen verwendet. Der folgende XML-Code fügt z. B. dem CSFile-Elementtyp alle CS-Dateien außer DoNotBuild.cs hinzu, die sich im Verzeichnis befinden.

<ItemGroup>
    <CSFile  Include="*.cs"  Exclude="DoNotBuild.cs"/>
</ItemGroup>

Das Exclude-Attribut wirkt sich nur auf Elemente aus, die über das Include-Attribut in dem Item-Element hinzugefügt wurden, das beide enthält. Im folgenden Beispiel würde die im vorherigen Item-Element hinzugefügte Datei Form1.cs also nicht ausgeschlossen werden.

<Compile Include="*.cs" />
<Compile Include="*.res" Exclude="Form1.cs">

Weitere Informationen finden Sie unter Vorgehensweise: Ausschließen von Dateien aus dem Buildvorgang.

Elementmetadaten

Zusätzlich zu den Informationen aus den Attributen Include und Exclude können Elemente Metadaten enthalten. Diese Metadaten können von Aufgaben verwendet werden, die weitere Informationen zu den Elementen oder zur Batchverarbeitung von Aufgaben und Zielen benötigen. Weitere Informationen finden Sie unter MSBuild Batching (Batchverarbeitung).

Bei Metadaten handelt es sich um eine Auflistung von Schlüssel-Wert-Paaren, die in der Projektdatei als untergeordnete Elemente eines Item-Elements deklariert sind. Der Name des untergeordneten Elements entspricht dem Metadatennamen, und der Wert des untergeordneten Elements entspricht dem Metadatenwert.

Die Metadaten sind dem Item-Element zugeordnet, in dem sie enthalten sind. Der folgende XML-Code fügt z. B. den Elementen one.cs und two.cs des CSFile-Elementtyps Culture-Metadaten mit dem Wert Fr hinzu.

<ItemGroup>
    <CSFile Include="one.cs;two.cs">
        <Culture>Fr</Culture>
    </CSFile>
</ItemGroup>

Ein Element kann über 0 (null) oder mehr Metadatenwerte verfügen. Metadaten lassen sich immer ändern. Wenn Sie Metadaten auf einen leeren Wert festlegen, entfernen Sie sie unwiderruflich aus dem Build.

Verweisen auf Elementmetadaten in einer Projektdatei

Mithilfe der Syntax %(ItemMetadataName) kann in der gesamten Projektdatei auf Elementmetadaten verwiesen werden. Bei Mehrdeutigkeiten können Sie mit dem Namen des Elementtyps einen Verweis qualifizieren. Sie können z.B. %(ItemType.ItemMetaDataName) festlegen. Im folgenden Beispiel werden Display-Metadaten verwendet, um den Task Message in einem Batch zusammenzufassen. Weitere Informationen zur Verwendung von Elementmetadaten für die Batchverarbeitung finden Sie unter Item Metadata in Task Batching (Elementmetadaten bei der Batchverarbeitung von Aufgaben).

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    <ItemGroup>
        <Stuff Include="One.cs" >
            <Display>false</Display>
        </Stuff>
        <Stuff Include="Two.cs">
            <Display>true</Display>
        </Stuff>
    </ItemGroup>
    <Target Name="Batching">
        <Message Text="@(Stuff)" Condition=" '%(Display)' == 'true' "/>
    </Target>
</Project>

Bekannte Elementmetadaten

Wenn einem Elementtypen ein Element hinzugefügt wird, werden diesem Element bekannte Metadaten zugewiesen. So verfügen z. B. alle Elemente über die bekannten Metadaten %(Filename), deren Wert dem Dateinamen des Elements entspricht (ohne Erweiterung). Weitere Informationen finden Sie unter Well-known Item Metadata (Bekannte Elementmetadaten).

Umwandeln von Elementtypen mithilfe von Metadaten

Elementlisten können mithilfe von Metadaten in neue Elementlisten umgewandelt werden. Sie können z.B. mit dem Ausdruck @(CppFiles -> '%(Filename).obj') einen CppFiles-Elementtyp, der über Elemente in Form von .cpp-Dateien verfügt, in eine entsprechende Liste von .obj-Dateien umwandeln.

Der folgende Code erstellt einen CultureResource-Elementtyp, der Kopien aller EmbeddedResource-Elemente mit Culture-Metadaten enthält. Der Culture-Metadatenwert ist nun der Wert der neuen Metadaten CultureResource.TargetDirectory.

<Target Name="ProcessCultureResources">
    <ItemGroup>
        <CultureResource Include="@(EmbeddedResource)"
            Condition="'%(EmbeddedResource.Culture)' != ''">
            <TargetDirectory>%(EmbeddedResource.Culture) </TargetDirectory>
        </CultureResource>
    </ItemGroup>
</Target>

Weitere Vorgänge für Elemente finden Sie unter Elementfunktionen sowie unter MSBuild-Transformationen.

Elementdefinitionen

Sie können jedem Elementtyp mit dem ItemDefinitionGroup-Element Standardmetadaten hinzufügen. Standardmetadaten sind genau wie bekannte Metadaten allen Elementen des jeweils angegebenen Elementtyps zugeordnet. Standardmetadaten können in einer Elementdefinition explizit überschrieben werden. Der folgende XML-Code vergibt z.B. an die Compile-Elemente one.cs und three.cs die Metadaten BuildDay mit dem Wert „Monday“. Der Code vergibt an das Element two.cs die Metadaten BuildDay mit dem Wert „Tuesday“.

<ItemDefinitionGroup>
    <Compile>
        <BuildDay>Monday</BuildDay>
    </Compile>
</ItemDefinitionGroup>
<ItemGroup>
    <Compile Include="one.cs;three.cs" />
    <Compile Include="two.cs">
        <BuildDay>Tuesday</BuildDay>
    </Compile>
</ItemGroup>

Weitere Informationen finden Sie unter Item Definitions (Elementdefinitionen).

Attribute für Elemente im ItemGroup-Element eines Ziels

Target-Elemente enthalten möglicherweise ItemGroup-Elemente, die Item-Elemente enthalten können. Die Attribute in diesem Abschnitt sind gültig, wenn sie für ein Element in einer ItemGroup angegeben werden, die sich in einem Target befindet.

Entfernen des Attributs

Das Remove-Attribut entfernt bestimmte Elemente (Dateien) aus dem Elementtyp. Dieses Attribut wurde in .NET Framework 3.5 eingeführt (nur von Zielen innerhalb). Sowohl die Ziele innerhalb als auch außerhalb werden ab MSBuild 15.0 unterstützt.

Das folgende Beispiel veranschaulicht das Entfernen aller .config-Dateien aus dem Compile-Elementtyp.

<Target>
    <ItemGroup>
        <Compile Remove="*.config"/>
    </ItemGroup>
</Target>

MatchOnMetadata-Attribut

Das MatchOnMetadata-Attribut gilt nur für Remove-Attribute, die auf andere Elemente verweisen (z. B. Remove="@(Compile);@(Content)"). Es weist den Remove-Vorgang an, Elemente anhand der Werte angegebener Metadatennamen und nicht anhand der Elementwerte abzugleichen.

Vergleichsregel für B Remove="@(A)" MatchOnMetadata="M": Hiermit werden alle Elemente aus B entfernt, die Metadaten M enthalten, deren Metadatenwert V für M einem beliebigen Element aus A mit Metadaten M des Werts V entspricht.

<Project>
  <ItemGroup>
    <A Include='a1' M1='1' M2='a' M3="e"/>
    <A Include='b1' M1='2' M2='x' M3="f"/>
    <A Include='c1' M1='3' M2='y' M3="g"/>
    <A Include='d1' M1='4' M2='b' M3="h"/>

    <B Include='a2' M1='x' m2='c' M3="m"/>
    <B Include='b2' M1='2' m2='x' M3="n"/>
    <B Include='c2' M1='2' m2='x' M3="o"/>
    <B Include='d2' M1='3' m2='y' M3="p"/>
    <B Include='e2' M1='3' m2='Y' M3="p"/>
    <B Include='f2' M1='4'        M3="r"/>
    <B Include='g2'               M3="s"/>

    <B Remove='@(A)' MatchOnMetadata='M1;M2'/>
  </ItemGroup>

  <Target Name="PrintEvaluation">
    <Message Text="%(B.Identity) M1='%(B.M1)' M2='%(B.M2)' M3='%(B.M3)'" />
  </Target>
</Project>

Im Beispiel werden die Elementwerte b2, c2 und d2 aus folgenden Grund aus dem B-Element entfernt:

  • b2 und c2 aus B stimmen mit b1 aus A in M1=2 und M2=x überein.
  • d2 aus B stimmt mit c1 aus A in M1=3 und M2=y überein.

Die Message-Aufgabe gibt folgende Daten aus:

  a2 M1='x' M2='c' M3='m'
  e2 M1='3' M2='Y' M3='p'
  f2 M1='4' M2='' M3='r'
  g2 M1='' M2='' M3='s'

Beispiel für die Verwendung von MatchOnMetadata von MSBuild:

      <_TransitiveItemsToCopyToOutputDirectory Remove="@(_ThisProjectItemsToCopyToOutputDirectory)" MatchOnMetadata="TargetPath" MatchOnMetadataOptions="PathLike" />

In dieser Zeile werden Elemente aus _TransitiveItemsToCopyToOutputDirectory entfernt, die über dieselben TargetPath-Metadatenwerte aus Elementen in _ThisProjectItemsToCopyToOutputDirectory verfügen.

MatchOnMetadataOptions-Attribut

Gibt die Strategie zum Zeichenfolgenabgleich an, die von MatchOnMetadata zum Abgleichen der Metadatenwerte zwischen Elementen verwendet wird. (Beim Abgleich von Metadatennamen ist die Groß-/Kleinschreibung nicht relevant.) Mögliche Werte sind CaseSensitive, CaseInsensitive oder PathLike. Der Standardwert ist CaseSensitive.

PathLike wendet die pfadorientierte Normalisierung auf die Werte an. Beispielsweise werden Schrägstrichausrichtungen normalisiert, nachgestellte Schrägstriche ignoriert, . und .. entfernt und alle relativen Pfade als absolut für das aktuelle Verzeichnis festgelegt.

KeepMetadata-Attribut

Wenn ein Element in einem Ziel erstellt wird, enthält das Item-Element möglicherweise das KeepMetadata-Attribut. Wenn dieses Attribut angegeben wird, werden nur die Metadaten aus dem Quellelement in das Zielelement übertragen, die in der durch Semikolons getrennten Liste von Namen angegeben sind. Wird für dieses Attribut ein leerer Wert angegeben, ist dies, als wäre nichts angegeben worden. Das KeepMetadata-Attribut wurde in .NET Framework 4.5 eingeführt.

Das folgende Beispiel veranschaulicht, wie das KeepMetadata-Attribut verwendet wird.

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"
ToolsVersion="4.0">

    <ItemGroup>
        <FirstItem Include="rhinoceros">
            <Class>mammal</Class>
            <Size>large</Size>
        </FirstItem>

    </ItemGroup>
    <Target Name="MyTarget">
        <ItemGroup>
            <SecondItem Include="@(FirstItem)" KeepMetadata="Class" />
        </ItemGroup>

        <Message Text="FirstItem: %(FirstItem.Identity)" />
        <Message Text="  Class: %(FirstItem.Class)" />
        <Message Text="  Size:  %(FirstItem.Size)"  />

        <Message Text="SecondItem: %(SecondItem.Identity)" />
        <Message Text="  Class: %(SecondItem.Class)" />
        <Message Text="  Size:  %(SecondItem.Size)"  />
    </Target>
</Project>

<!--
Output:
  FirstItem: rhinoceros
    Class: mammal
    Size:  large
  SecondItem: rhinoceros
    Class: mammal
    Size:
-->

RemoveMetadata-Attribut

Wenn ein Element in einem Ziel erstellt wird, enthält das Item-Element möglicherweise das RemoveMetadata-Attribut. Wenn dieses Attribut angegeben wird, werden alle Metadaten aus dem Quellelement in das Zielelement übertragen. Davon ausgenommen sind Metadaten, deren Namen in der durch Semikolons getrennten Liste von Namen enthalten sind. Wird für dieses Attribut ein leerer Wert angegeben, ist dies, als wäre nichts angegeben worden. Das RemoveMetadata-Attribut wurde in .NET Framework 4.5 eingeführt.

Das folgende Beispiel veranschaulicht, wie das RemoveMetadata-Attribut verwendet wird.

<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

    <PropertyGroup>
        <MetadataToRemove>Size;Material</MetadataToRemove>
    </PropertyGroup>

    <ItemGroup>
        <Item1 Include="stapler">
            <Size>medium</Size>
            <Color>black</Color>
            <Material>plastic</Material>
        </Item1>
    </ItemGroup>

    <Target Name="MyTarget">
        <ItemGroup>
            <Item2 Include="@(Item1)" RemoveMetadata="$(MetadataToRemove)" />
        </ItemGroup>

        <Message Text="Item1: %(Item1.Identity)" />
        <Message Text="  Size:     %(Item1.Size)" />
        <Message Text="  Color:    %(Item1.Color)" />
        <Message Text="  Material: %(Item1.Material)" />
        <Message Text="Item2: %(Item2.Identity)" />
        <Message Text="  Size:     %(Item2.Size)" />
        <Message Text="  Color:    %(Item2.Color)" />
        <Message Text="  Material: %(Item2.Material)" />
    </Target>
</Project>

<!--
Output:
  Item1: stapler
    Size:     medium
    Color:    black
    Material: plastic
  Item2: stapler
    Size:
    Color:    black
    Material:
-->

Weitere Vorgänge für Elemente finden Sie unter Elementfunktionen.

KeepDuplicates-Attribut

Wenn ein Element in einem Ziel erstellt wird, enthält das Item-Element möglicherweise das KeepDuplicates-Attribut. KeepDuplicates ist ein Boolean-Attribut, das angibt, ob ein Element der Zielgruppe hinzugefügt werden soll, wenn es sich um ein exaktes Duplikat eines bereits vorhandenen Elements handelt.

Wenn das Quell- und Zielelement den gleichen Include-Wert aber unterschiedliche Metadaten aufweisen, wird das Element auch dann hinzugefügt, wenn KeepDuplicates auf false festgelegt ist. Wird für dieses Attribut ein leerer Wert angegeben, ist dies, als wäre nichts angegeben worden. Das KeepDuplicates-Attribut wurde in .NET Framework 4.5 eingeführt.

Das folgende Beispiel veranschaulicht, wie das KeepDuplicates-Attribut verwendet wird.

<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

    <ItemGroup>
        <Item1 Include="hourglass;boomerang" />
        <Item2 Include="hourglass;boomerang" />
    </ItemGroup>

    <Target Name="MyTarget">
        <ItemGroup>
            <Item1 Include="hourglass" KeepDuplicates="false" />
            <Item2 Include="hourglass" />
        </ItemGroup>

        <Message Text="Item1: @(Item1)" />
        <Message Text="  %(Item1.Identity)  Count: @(Item1->Count())" />
        <Message Text="Item2: @(Item2)" />
        <Message Text="  %(Item2.Identity)  Count: @(Item2->Count())" />
    </Target>
</Project>

<!--
Output:
  Item1: hourglass;boomerang
    hourglass  Count: 1
    boomerang  Count: 1
  Item2: hourglass;boomerang;hourglass
    hourglass  Count: 2
    boomerang  Count: 1
-->

Da das KeepDuplicates-Attribut zusätzlich zu den Elementwerten auch die Metadaten der Elemente berücksichtigt, ist es wichtig zu wissen, was mit den Metadaten geschieht. Siehe hierzu beispielsweise Erkennen von Duplikaten bei Verwendung der Metadatenelementfunktion.

Aktualisieren von Metadaten für Elemente in einer ItemGroup außerhalb eines Ziels

Für Elemente außerhalb von Zielen können vorhandene Metadaten über das Update-Attribut aktualisiert werden. Dieses Attribut ist nicht für Elemente unter Zielen verfügbar.

<Project>
    <PropertyGroup>
        <MetadataToUpdate>pencil</MetadataToUpdate>
    </PropertyGroup>

    <ItemGroup>
        <Item1 Include="stapler">
            <Size>medium</Size>
            <Color>black</Color>
            <Material>plastic</Material>
        </Item1>
        <Item1 Include="pencil">
            <Size>small</Size>
            <Color>yellow</Color>
            <Material>wood</Material>
        </Item1>
        <Item1 Include="eraser">
            <Color>red</Color>
        </Item1>
        <Item1 Include="notebook">
            <Size>large</Size>
            <Color>white</Color>
            <Material>paper</Material>
        </Item1>

        <Item2 Include="notebook">
            <Size>SMALL</Size>
            <Color>YELLOW</Color>
        </Item2>

        <!-- Metadata can be expressed either as attributes or as elements -->
        <Item1 Update="$(MetadataToUpdate);stapler;er*r;@(Item2)" Price="10" Material="">
            <Color>RED</Color>
        </Item1>
    </ItemGroup>

    <Target Name="MyTarget">
        <Message Text="Item1: %(Item1.Identity)
    Size: %(Item1.Size)
    Color: %(Item1.Color)
    Material: %(Item1.Material)
    Price: %(Item1.Price)" />
    </Target>
</Project>

<!--  
Item1: stapler
    Size: medium
    Color: RED
    Material:
    Price: 10
Item1: pencil
    Size: small
    Color: RED
    Material:
    Price: 10
Item1: eraser
    Size:
    Color: RED
    Material:
    Price: 10
Item1: notebook
    Size: large
    Color: RED
    Material:
    Price: 10
-->

In MSBuild (Version 16.6 und höher) unterstützt das Update-Attribut qualifizierte Metadatenverweise, um das Importieren von Metadaten aus mindestens zwei Elementen zu vereinfachen.

<Project>
    <ItemGroup>
        <Item1 Include="stapler">
            <Size>medium</Size>
            <Color>black</Color>
            <Material>plastic</Material>
        </Item1>
        <Item1 Include="pencil">
            <Size>small</Size>
            <Color>yellow</Color>
            <Material>wood</Material>
        </Item1>
        <Item1 Include="eraser">
            <Size>small</Size>
            <Color>red</Color>
            <Material>gum</Material>
        </Item1>
        <Item1 Include="notebook">
            <Size>large</Size>
            <Color>white</Color>
            <Material>paper</Material>
        </Item1>

        <Item2 Include="pencil">
            <Size>MEDIUM</Size>
            <Color>RED</Color>
            <Material>PLASTIC</Material>
            <Price>10</Price>
        </Item2>

        <Item3 Include="notebook">
            <Size>SMALL</Size>
            <Color>BLUE</Color>
            <Price>20</Price>
        </Item3>

        <!-- Metadata can be expressed either as attributes or as elements -->
        <Item1 Update="@(Item2);er*r;@(Item3)" Size="%(Size)" Color="%(Item2.Color)" Price="%(Item3.Price)" Model="2020">
            <Material Condition="'%(Item2.Material)' != ''">Premium %(Item2.Material)</Material>
        </Item1>
    </ItemGroup>

    <Target Name="MyTarget">
        <Message Text="Item1: %(Item1.Identity)
    Size: %(Item1.Size)
    Color: %(Item1.Color)
    Material: %(Item1.Material)
    Price: %(Item1.Price)
    Model: %(Item1.Model)" />
    </Target>
</Project>

<!--  
Item1: stapler
    Size: medium
    Color: black
    Material: plastic
    Price:
    Model:
Item1: pencil
    Size: small
    Color: RED
    Material: Premium PLASTIC
    Price:
    Model: 2020
Item1: eraser
    Size: small
    Color:
    Material: gum
    Price:
    Model: 2020
Item1: notebook
    Size: large
    Color:
    Material: paper
    Price: 20
    Model: 2020
-->

Anmerkungen:

  • Nicht qualifizierte Metadaten (%(MetadataName)) werden an den zu aktualisierenden Elementtyp (Item1 im Beispiel oben) gebunden. Qualifizierte Metadaten (%(Item2.Color)) werden innerhalb des Satzes der erfassten übereinstimmenden Elementtypen aus dem Aktualisierungsausdruck gebunden.
  • Wenn ein Element mehrmals innerhalb von und zwischen mehreren referenzierten Elementen übereinstimmt:
    • Das letzte Vorkommen jedes referenzierten Elementtyps wird erfasst (also ein erfasstes Element pro Elementtyp).
    • Dies entspricht dem Verhalten der Batchverarbeitung von Aufgabenelementen unter den Zielen.
  • Hier können%()-Verweise eingefügt werden:
    • Metadaten
    • Metadatenbedingungen
  • Beim Abgleich von Metadatennamen wird nicht zwischen Groß- und Kleinschreibung unterschieden.

Aktualisieren von Metadaten für Elemente in einer ItemGroup eines Ziels

Metadaten können auch in Zielen mit einer weniger ausdrucksstarken Syntax als Update geändert werden:

<Project>
    <ItemGroup>
        <Item1 Include="stapler">
            <Size>medium</Size>
            <Color>black</Color>
            <Material>plastic</Material>
        </Item1>
        <Item1 Include="pencil">
            <Size>small</Size>
            <Color>yellow</Color>
            <Material>wood</Material>
        </Item1>
        <Item1 Include="eraser">
            <Size>small</Size>
            <Color>red</Color>
            <Material>gum</Material>
        </Item1>
        <Item1 Include="notebook">
            <Size>large</Size>
            <Color>white</Color>
            <Material>paper</Material>
        </Item1>

        <Item2 Include="pencil">
            <Size>MEDIUM</Size>
            <Color>RED</Color>
            <Material>PLASTIC</Material>
            <Price>10</Price>
        </Item2>

        <Item2 Include="ruler">
            <Color>GREEN</Color>
        </Item2>

    </ItemGroup>

    <Target Name="MyTarget">
        <ItemGroup>
            <!-- Metadata can be expressed either as attributes or as elements -->
            <Item1 Size="GIGANTIC" Color="%(Item2.Color)">
                <Material Condition="'%(Item2.Material)' != ''">Premium %(Item2.Material)</Material>
            </Item1>
        </ItemGroup>

        <Message Text="Item1: %(Item1.Identity)
    Size: %(Item1.Size)
    Color: %(Item1.Color)
    Material: %(Item1.Material)
    Price: %(Item1.Price)
    Model: %(Item1.Model)" />
    </Target>
</Project>

<!--  
Item1: stapler
    Size: GIGANTIC
    Color: GREEN
    Material: Premium PLASTIC
    Price:
    Model:
Item1: pencil
    Size: GIGANTIC
    Color: GREEN
    Material: Premium PLASTIC
    Price:
    Model:
Item1: eraser
    Size: GIGANTIC
    Color: GREEN
    Material: Premium PLASTIC
    Price:
    Model:
Item1: notebook
    Size: GIGANTIC
    Color: GREEN
    Material: Premium PLASTIC
    Price:
    Model:
-->

Zugehöriger Inhalt