MSBuild-Elemente

2025-08-08

MSBuild-Elemente sind Eingaben im Buildsystem und stellen in der Regel Dateien dar (die Dateien werden im Include Attribut angegeben). Elemente werden basierend auf ihren Elementnamen in Elementtypen gruppiert. Elementtypen sind benannte Listen von Elementen, die als Parameter für Aufgaben verwendet werden können. Die Aufgaben verwenden die Elementwerte, um die Schritte des Buildvorgangs auszuführen.

Da Elemente nach dem Elementtyp benannt werden, zu dem sie gehören, können die Begriffe "Element" und "Elementwert" austauschbar verwendet werden.

Erstellen von Elementen in einer Projektdatei

Sie deklarieren Elemente in der Projektdatei als untergeordnete Elemente eines ItemGroup-Elements . 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. Das Include Attribut des Elements gibt die Elemente (Dateien) an, die in diesen Elementtyp eingeschlossen werden sollen. Mit dem folgenden XML-Code wird beispielsweise ein Elementtyp erstellt, der den Namen Compilehat, der zwei Dateien enthält.

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

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

Der folgende XML-Code erstellt denselben Elementtyp, indem beide Dateien in einem Include Attribut deklariert werden. Beachten Sie, dass die Dateinamen durch ein Semikolon getrennt sind.

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

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

Erstellen von Elementen während der Ausführung

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

Jeder Vorgang kann ein Element ausgeben. Zum Ausgeben eines Elements muss das Task-Element über ein untergeordnetes Output-Element verfügen, das über ein ItemName Attribut verfügt.
Die CreateItem-Aufgabe kann ein Element ausgeben. Diese Verwendung ist veraltet.
Target Elemente können ItemGroup-Elemente enthalten, die Elementelemente enthalten können.

Verweisen auf Elemente in einer Projektdatei

Um auf Elementtypen in der gesamten Projektdatei zu verweisen, verwenden Sie die Syntax @(ItemType). Sie würden z. B. auf den Elementtyp im vorherigen Beispiel verweisen, indem @(Compile)Sie . Mithilfe dieser Syntax können Sie Elemente an Aufgaben übergeben, indem Sie den Elementtyp als Parameter dieser Aufgabe angeben. Weitere Informationen finden Sie unter How to: Select the files to build.

Standardmäßig werden die Elemente eines Elementtyps durch Semikolons getrennt (;), wenn er erweitert wird. Mit der Syntax @(ItemType, 'separator') können Sie ein anderes Trennzeichen als die Standardeinstellung angeben. Weitere Informationen finden Sie unter How to: Display an item list separated with commas.

Verwenden von Wildcards zum Angeben von Elementen

Sie können die **Zeichen " und *? "Wildcard" verwenden, um eine Gruppe von Dateien als Eingaben für einen Build anzugeben, anstatt jede Datei separat aufzulisten.

Das ? Wildcardzeichen entspricht einem einzelnen Zeichen.
Das * Wildcardzeichen entspricht null oder mehr Zeichen.
Die ** Wildcardzeichensequenz entspricht einem teilweisen Pfad.

Sie können beispielsweise alle .cs Dateien im Verzeichnis angeben, die die Projektdatei enthalten, indem Sie das folgende Element in der Projektdatei verwenden.

<CSFile Include="*.cs"/>

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

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

Wenn Sie Literale * oder ? Zeichen in ein Element ohne Wildcarderweiterung einschließen möchten, müssen Sie die Wildcardzeichen escapen.

Weitere Informationen zu Wildcardzeichen finden Sie unter How to: Select the files to build.

Verwenden des Exclude-Attributs

Elementelemente können das Exclude Attribut enthalten, das bestimmte Elemente (Dateien) vom Elementtyp ausschließt. Das Exclude Attribut wird in der Regel zusammen mit Wildcardzeichen verwendet. Mit dem folgenden XML-Code wird beispielsweise jede .cs Datei im Verzeichnis dem CSFile Elementtyp hinzugefügt, mit Ausnahme der DoNotBuild.cs Datei.

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

Das Exclude Attribut wirkt sich nur auf die Elemente aus, die vom Include Attribut im Elementelement hinzugefügt werden, das beide enthält. Im folgenden Beispiel wird die Datei Form1.cs nicht ausgeschlossen, die im vorherigen Elementelement hinzugefügt wurde.

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

Weitere Informationen finden Sie unter How to: Exclude files from the build.

Elementmetadaten

Elemente können zusätzlich zu den Informationen in den Include Und Exclude Attributen Metadaten enthalten. Diese Metadaten können von Aufgaben verwendet werden, die weitere Informationen zu den Elementen oder zum Stapeln von Aufgaben und Zielen erfordern. Weitere Informationen finden Sie unter MSBuild Batching (Batchverarbeitung).

Metadaten sind eine Sammlung von Schlüssel-Wert-Paaren, die in der Projektdatei als untergeordnete Elemente eines Elementelements deklariert werden. Der Name des untergeordneten Elements ist der Name der Metadaten, und der Wert des untergeordneten Elements ist der Wert der Metadaten.

Die Metadaten sind dem Elementelement zugeordnet, das es enthält. Mit dem folgenden XML-Code werden beispielsweise Metadaten hinzugefügtCulture, die sowohl dem one.cs als auch den two.cs Elementen des CSFile Elementtyps den Wert Fr aufweisen.

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

Ein Element kann null oder mehr Metadatenwerte enthalten. Sie können Metadatenwerte jederzeit ändern. Wenn Sie Metadaten auf einen leeren Wert festlegen, entfernen Sie sie effektiv aus dem Build.

Referenzelementmetadaten in einer Projektdatei

Mithilfe der Syntax %(ItemMetadataName)können Sie auf Elementmetadaten in der gesamten Projektdatei verweisen. Wenn Mehrdeutigkeit vorhanden ist, können Sie einen Verweis mithilfe des Namens des Elementtyps qualifizieren. Sie können z.B. %(ItemType.ItemMetaDataName) festlegen. Im folgenden Beispiel werden die Display Metadaten verwendet, um die Message Aufgabe zu stapeln. Weitere Informationen zur Verwendung von Elementmetadaten für die Batchverarbeitung finden Sie unter Elementmetadaten in der Aufgabenbatchierung.

<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 Elementtyp ein Element hinzugefügt wird, wird diesem Element einige bekannte Metadaten zugewiesen. Beispielsweise verfügen alle Elemente über die bekannten Metadaten %(Filename), deren Wert der Dateiname des Elements ist (ohne die Erweiterung). Weitere Informationen finden Sie unter Bekannte Elementmetadaten.

Transformieren von Elementtypen mithilfe von Metadaten

Sie können Elementlisten mithilfe von Metadaten in neue Elementlisten umwandeln. Sie können z. B. einen Elementtyp CppFiles mit Elementen, die Dateien darstellen.cpp, mithilfe des Ausdrucks @(CppFiles -> '%(Filename).obj')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 wird zum 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 zu Elementen finden Sie unter MSBuild-Elementfunktionen und Transformationen.

Elementdefinitionen

Sie können einem beliebigen Elementtyp Standardmetadaten hinzufügen, indem Sie das ItemDefinitionGroup-Element verwenden. Wie bekannte Metadaten werden die Standardmetadaten allen Elementen des von Ihnen angegebenen Elementtyps zugeordnet. Sie können Standardmetadaten in einer Elementdefinition explizit außer Kraft setzen. Die folgende XML gibt beispielsweise die Compile Elemente one.cs und three.cs die Metadaten BuildDay mit dem Wert "Montag" an. Der Code gibt das Element two.cs den Metadaten BuildDay mit dem Wert "Dienstag" an.

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

Attribute für Elemente in einer ItemGroup eines Ziels

Target Elemente können ItemGroup-Elemente enthalten, die Elementelemente enthalten können. Die Attribute in diesem Abschnitt sind gültig, wenn sie für ein Element in einem Element in einem ItemGroup in einem Target.

Attribut entfernen

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

Im folgenden Beispiel wird jede .config Datei aus dem Compile Elementtyp entfernt.

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

MatchOnMetadata-Attribut

Das MatchOnMetadata Attribut gilt nur für Remove Attribute, die auf andere Elemente verweisen (z Remove="@(Compile);@(Content)". B. ) und weist den Remove Vorgang an, Elemente basierend auf den Werten der angegebenen Metadatennamen abzugleichen, anstatt basierend auf den Elementwerten zu übereinstimmen.

Übereinstimmungsregel für B Remove="@(A)" MatchOnMetadata="M": Entfernen aller Elemente, aus B denen Metadaten Menthalten, deren Metadatenwert V für M jedes Element A mit Metadaten M des Werts Vübereinstimmt.

<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 Elementwerte b2, c2und d2 sie werden aus dem Element B entfernt, da:

b2und c2 vom B Spiel gegen b1 von an M1=2A undM2=x
d2von B Spielen gegen c1 von an M1=3A undM2=y

Der Message Vorgang gibt Folgendes 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'

Beispielverwendung von MatchOnMetadataMSBuild:

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

Diese Zeile entfernt Elemente mit _TransitiveItemsToCopyToOutputDirectory denselben TargetPath Metadatenwerten aus Elementen in _ThisProjectItemsToCopyToOutputDirectory

MatchOnMetadataOptions-Attribut

Gibt die Zeichenfolgenabgleichsstrategie an, die zum Abgleichen der Metadatenwerte zwischen Elementen verwendet wird MatchOnMetadata (Metadatennamen werden immer mit Groß-/Kleinschreibung abgeglichen). Mögliche Werte sind CaseSensitive, CaseInsensitiveoder PathLike. Der Standardwert ist CaseSensitive.

PathLike Wendet die pfadfähige Normalisierung auf die Werte an, z. B. die Normalisierung von Schrägstrichen, das Ignorieren von nachgestellten Schrägstrichen, das Entfernen . und ..das Festlegen aller relativen Pfade im aktuellen Verzeichnis.

KeepMetadata-Attribut

Wenn ein Element innerhalb eines Ziels generiert wird, kann das Elementelement das KeepMetadata Attribut enthalten. Wenn dieses Attribut angegeben ist, werden nur die Metadaten, die in der durch Semikolons getrennten Liste der Namen angegeben sind, vom Quellelement in das Zielelement übertragen. Ein leerer Wert für dieses Attribut entspricht nicht der Angabe. Das KeepMetadata Attribut wurde in .NET Framework 4.5 eingeführt.

Das folgende Beispiel veranschaulicht die Verwendung des KeepMetadata Attributs.

<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 innerhalb eines Ziels generiert wird, kann das Elementelement das RemoveMetadata Attribut enthalten. Wenn dieses Attribut angegeben ist, werden alle Metadaten vom Quellelement in das Zielelement übertragen, mit Ausnahme von Metadaten, deren Namen in der durch Semikolons getrennten Liste der Namen enthalten sind. Ein leerer Wert für dieses Attribut entspricht nicht der Angabe. Das RemoveMetadata Attribut wurde in .NET Framework 4.5 eingeführt.

Das folgende Beispiel veranschaulicht die Verwendung des RemoveMetadata Attributs.

<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 zu Elementen finden Sie unter MSBuild-Elementfunktionen.

KeepDuplicates-Attribut

Wenn ein Element innerhalb eines Ziels generiert wird, kann das Elementelement das KeepDuplicates Attribut enthalten. KeepDuplicates ist ein Boolean Attribut, das angibt, ob ein Element der Zielgruppe hinzugefügt werden soll, wenn das Element ein genaues Duplikat eines vorhandenen Elements ist.

Wenn das Quell- und Zielelement denselben Include Wert, aber unterschiedliche Metadaten aufweisen, wird das Element hinzugefügt, auch wenn KeepDuplicates dieser wert falsefestgelegt ist. Ein leerer Wert für dieses Attribut entspricht nicht der Angabe. Das KeepDuplicates Attribut wurde in .NET Framework 4.5 eingeführt.

Das folgende Beispiel veranschaulicht die Verwendung des KeepDuplicates Attributs.

<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 die Metadaten von Elementen zusätzlich zu den Elementwerten berücksichtigt, ist es wichtig zu wissen, was mit den Metadaten geschieht. Weitere Informationen finden Sie unter "Erkennen von Duplikaten bei Verwendung der Metadatenelementfunktion".

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

Elemente außerhalb von Zielen können ihre vorhandenen Metadaten über das Update Attribut aktualisiert haben. Dieses Attribut ist für Elemente unter Zielen nicht 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 zwei oder mehr Elementen zu erleichtern.

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

Bemerkungen:

Nicht qualifizierte Metadaten (%(MetadataName)) binden an den zu aktualisierenden Elementtyp (Item1 im obigen Beispiel). Qualifizierte Metadaten (%(Item2.Color)) binden innerhalb der Gruppe erfasster übereinstimmender Elementtypen aus dem Update-Ausdruck.
Wenn ein Element mehrmals innerhalb 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 Aufgabenelementbatchierung unter Zielen.
Wo man %() Verweise einfügen kann:
- Metadaten
- Metadatenbedingungen
Bei dem Metadatennamenabgleich wird die Groß-/Kleinschreibung nicht beachtet.

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

Metadaten können auch innerhalb von Zielen durch eine weniger ausdrucksstarke Syntax geändert werden als Update:

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