MSBuild-ElementeMSBuild items

MSBuild-Elemente sind Eingaben in das Buildsystem. In der Regel handelt es sich dabei um Dateien (die Dateien sind im Include-Attribut angegeben).MSBuild items are inputs into the build system, and they typically represent files (the files are specified in the Include attribute). Elemente werden auf Grundlage benutzerdefinierter Elementnamen in Elementtypen gruppiert.Items are grouped into item types based on their element names. Elementtypen sind benannte Listen von Elementen, die als Parameter für Aufgaben verwendet werden können.Item types are named lists of items that can be used as parameters for tasks. In den Aufgaben werden die Schritte des Buildprozesses mithilfe der Elementwerte ausgeführt.The tasks use the item values to perform the steps of the build process.

Da Elemente anhand des Elementtyps benannt werden, zu dem sie gehören, können die Begriffe „Element“ und „Elementwert“ synonym verwendet werden.Because items are named by the item type to which they belong, the terms "item" and "item value" can be used interchangeably.

Erstellen von Elementen in einer ProjektdateiCreate items in a project file

Elemente werden in der Projektdatei als untergeordnete Elemente eines ItemGroup-Elements deklariert.You declare items in the project file as child elements of an ItemGroup element. Der Name des untergeordneten Elements ist der Typ des Elements.The name of the child element is the type of the item. Durch das Include-Attribut des Elements wird angegeben, welche Elemente (Dateien) in den jeweiligen Elementtyp aufgenommen werden sollen.The Include attribute of the element specifies the items (files) to be included with that item type. Im folgenden XML wird z.B. der mit Compile benannte Elementtyp erstellt, der zwei Dateien umfasst.For example, the following XML creates an item type that's named Compile, which includes two files.

<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.The item file2.cs doesn't replace the item file1.cs ; instead, the file name is appended to the list of values for the Compile item type.

Das folgende XML erstellt den gleichen Elementtyp, indem beide Dateien in einem Include-Attribut deklariert werden.The following XML creates the same item type by declaring both files in one Include attribute. Achten Sie darauf, dass die Dateinamen durch ein Semikolon voneinander getrennt sind.Notice that the file names are separated by a semicolon.

<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.The Include attribute is a path that is interpreted relative to the project file's folder, $(MSBuildProjectPath), even if the item is in an imported file such as a .targets file.

Erstellen von Elementen während der AusführungCreate items during execution

Elementen außerhalb von Ziel-Elementen werden während der Auswertungsphase eines Builds Werte zugewiesen.Items that are outside Target elements are assigned values during the evaluation phase of a build. Während der anschließenden Ausführungsphase können Elemente wie folgt erstellt oder geändert werden:During the subsequent execution phase, items can be created or modified in the following ways:

  • Jede Aufgabe kann ein Element ausgeben.Any task can emit an item. Das Aufgabe-Element muss über ein untergeordnetes Ausgabe-Element mit einem ItemName-Attribut verfügen, damit ein Element ausgegeben werden kann.To emit an item, the Task element must have a child Output element that has an ItemName attribute.

  • Die CreateItem-Aufgabe kann ein Element ausgeben.The CreateItem task can emit an item. Diese Verwendung ist veraltet.This usage is deprecated.

  • Ab .NET Framework 3.5 enthalten Target-Elemente möglicherweise ItemGroup-Elemente, die Item-Elemente enthalten.Starting in the .NET Framework 3.5, Target elements may contain ItemGroup elements that may contain item elements.

Verweisen auf Elemente in einer ProjektdateiReference items in a project file

Verwenden Sie die Syntax @(<ItemType>), um auf Elementtypen in der gesamten Projektdatei zu verweisen.To reference item types throughout the project file, you use the syntax @(<ItemType>). Auf den Elementtyp aus dem vorherigen Beispiel würden Sie z.B. mithilfe von @(Compile) verweisen.For example, you would reference the item type in the previous example by using @(Compile). Mithilfe dieser Syntax können Sie Elemente an Aufgaben übergeben, indem Sie den Elementtyp als einen Parameter dieser Aufgabe angeben.By using this syntax, you can pass items to tasks by specifying the item type as a parameter of that task. Weitere Informationen finden Sie unter Vorgehensweise: Auswählen von Dateien für den Buildvorgang.For more information, see How to: Select the files to build.

Standardmäßig sind die Elemente eines Elementtyps durch Semikolons (;) getrennt, wenn er erweitert wird.By default, the items of an item type are separated by semicolons (;) when it's expanded. Sie können die Syntax @(<ItemType>, '<separator>') verwenden, um ein anderes Trennzeichen als das Standardtrennzeichen anzugeben.You can use the syntax @(<ItemType>, '<separator>') to specify a separator other than the default. Weitere Informationen finden Sie unter Vorgehensweise: Anzeigen einer durch Trennzeichen getrennten Elementliste.For more information, see How to: Display an item list separated with commas.

Verwenden von Platzhaltern zum Angeben von ElementenUse wildcards to specify items

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.You can use the **, *, and ? wildcard characters to specify a group of files as inputs for a build instead of listing each file separately.

  • Das Platzhalterzeichen ? entspricht einem einzelnen Zeichen.The ? wildcard character matches a single character.
  • Das Platzhalterzeichen * entspricht 0 (null) oder mehr Zeichen.The * wildcard character matches zero or more characters.
  • Die Platzhalterzeichenfolge ** entspricht einem partiellen Pfad.The ** wildcard character sequence matches a partial path.

Sie können z.B. alle .cs-Dateien im Verzeichnis der Projektdatei angeben, indem Sie das folgende Element in der Projektdatei verwenden.For example, you can specify all the .cs files in the directory that contains the project file by using the following element in your project file.

<CSFile Include="*.cs"/>

Das folgende Element wählt alle .vb-Dateien auf Laufwerk D: aus:The following element selects all .vb files on the D: drive:

<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.If you would like to include literal * or ? characters in an item without wildcard expansion, you must escape the wildcard characters.

Weitere Informationen zu Platzhalterzeichen finden Sie unter Vorgehensweise: Auswählen von Dateien für den Buildvorgang.For more information about wildcard characters, see How to: Select the files to build.

Verwenden des Exclude-AttributsUse the Exclude attribute

Item-Elemente können das Exclude-Attribut enthalten, das bestimmte Elemente (Dateien) aus dem Elementtyp ausschließt.Item elements can contain the Exclude attribute, which excludes specific items (files) from the item type. Das Exclude-Attribut wird normalerweise zusammen mit Platzhalterzeichen verwendet.The Exclude attribute is typically used together with wildcard characters. Der folgende XML-Code fügt z.B. dem CSFile-Elementtyp alle CS -Dateien außer DoNotBuild.cs hinzu, die sich im Verzeichnis befinden.For example, the following XML adds every .cs file in the directory to the CSFile item type, except the DoNotBuild.cs file.

<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.The Exclude attribute affects only the items that are added by the Include attribute in the item element that contains them both. Im folgenden Beispiel würde die im vorherigen Item-Element hinzugefügte Datei Form1.cs also nicht ausgeschlossen werden.The following example wouldn't exclude the file Form1.cs , which was added in the preceding item element.

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

Weitere Informationen finden Sie unter Vorgehensweise: Ausschließen von Dateien aus dem Buildvorgang.For more information, see How to: Exclude files from the build.

ElementmetadatenItem metadata

Zusätzlich zu den Informationen aus den Attributen Include und Exclude können Elemente Metadaten enthalten.Items may contain metadata in addition to the information in the Include and Exclude attributes. Diese Metadaten können von Aufgaben verwendet werden, die weitere Informationen zu den Elementen oder zur Batchverarbeitung von Aufgaben und Zielen benötigen.This metadata can be used by tasks that require more information about the items or to batch tasks and targets. Weitere Informationen finden Sie unter MSBuild Batching (Batchverarbeitung).For more information, see Batching.

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.Metadata is a collection of key-value pairs that are declared in the project file as child elements of an item element. Der Name des untergeordneten Elements entspricht dem Metadatennamen, und der Wert des untergeordneten Elements entspricht dem Metadatenwert.The name of the child element is the name of the metadata, and the value of the child element is the value of the metadata.

Die Metadaten sind dem Item-Element zugeordnet, in dem sie enthalten sind.The metadata is associated with the item element that contains it. 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.For example, the following XML adds Culture metadata that has the value Fr to both the one.cs and the two.cs items of the CSFile item type.

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

Ein Element kann über 0 (null) oder mehr Metadatenwerte verfügen.An item can have zero or more metadata values. Metadaten lassen sich immer ändern.You can change metadata values at any time. Wenn Sie Metadaten auf einen leeren Wert festlegen, entfernen Sie sie unwiderruflich aus dem Build.If you set metadata to an empty value, you effectively remove it from the build.

Verweisen auf Elementmetadaten in einer ProjektdateiReference item metadata in a project file

Mithilfe der Syntax %(<ItemMetadataName>) kann in der gesamten Projektdatei auf Elementmetadaten verwiesen werden.You can reference item metadata throughout the project file by using the syntax %(<ItemMetadataName>). Bei Mehrdeutigkeiten können Sie mit dem Namen des Elementtyps einen Verweis qualifizieren.If ambiguity exists, you can qualify a reference by using the name of the item type. Sie können z. B. %(<ItemType.ItemMetaDataName>) angeben. Im folgenden Beispiel erfolgt die Batchverarbeitung des Nachrichtentasks mithilfe der Anzeigemetadaten.For example, you can specify %(<ItemType.ItemMetaDataName>).The following example uses the Display metadata to batch the Message task. Weitere Informationen zur Verwendung von Elementmetadaten für die Batchverarbeitung finden Sie unter Item Metadata in Task Batching (Elementmetadaten bei der Batchverarbeitung von Aufgaben).For more information about how to use item metadata for batching, see Item metadata in task batching.

<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 ElementmetadatenWell-known item metadata

Wenn einem Elementtypen ein Element hinzugefügt wird, werden diesem Element bekannte Metadaten zugewiesen.When an item is added to an item type, that item is assigned some well-known metadata. So verfügen z. B. alle Elemente über die bekannten Metadaten %(<Filename>), deren Wert dem Dateinamen des Elements entspricht (ohne Erweiterung).For example, all items have the well-known metadata %(<Filename>), whose value is the file name of the item (without the extension). Weitere Informationen finden Sie unter Well-known Item Metadata (Bekannte Elementmetadaten).For more information, see Well-known item metadata.

Umwandeln von Elementtypen mithilfe von MetadatenTransform item types by using metadata

Elementlisten können mithilfe von Metadaten in neue Elementlisten umgewandelt werden.You can transform item lists into new item lists by using metadata. 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.For example, you can transform an item type CppFiles that has items that represent .cpp files into a corresponding list of .obj files by using the expression @(CppFiles -> '%(Filename).obj').

Der folgende Code erstellt einen CultureResource-Elementtyp, der Kopien aller EmbeddedResource-Elemente mit Culture-Metadaten enthält.The following code creates a CultureResource item type that contains copies of all EmbeddedResource items with Culture metadata. Der Culture-Metadatenwert ist nun der Wert der neuen Metadaten CultureResource.TargetDirectory.The Culture metadata value becomes the value of the new metadata CultureResource.TargetDirectory.

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

Weitere Informationen finden Sie unter Transformationen.For more information, see Transforms.

ElementdefinitionenItem definitions

Ab .NET Framework 3.5 können Sie jedem Elementtypen mit dem ItemDefinitionGroup-Element Standardmetadaten hinzufügen.Starting in the .NET Framework 3.5, you can add default metadata to any item type by using the ItemDefinitionGroup element. Standardmetadaten sind genau wie bekannte Metadaten allen Elementen des jeweils angegebenen Elementtyps zugeordnet.Like well-known metadata, the default metadata is associated with all items of the item type that you specify. Standardmetadaten können in einer Elementdefinition explizit überschrieben werden.You can explicitly override default metadata in an item definition. Der folgende XML-Code vergibt z.B. an die Compile-Elemente one.cs und three.cs die Metadaten BuildDay mit dem Wert „Monday“.For example, the following XML gives the Compile items one.cs and three.cs the metadata BuildDay with the value "Monday". Der Code vergibt an das Element two.cs die Metadaten BuildDay mit dem Wert „Tuesday“.The code gives the item two.cs the metadata BuildDay with the value "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).For more information, see Item definitions.

Attribute für Elemente im ItemGroup-Element eines ZielsAttributes for items in an ItemGroup of a Target

Ab .NET Framework 3.5 enthalten Target-Elemente möglicherweise ItemGroup-Elemente, die Item-Elemente enthalten.Starting in the .NET Framework 3.5, Target elements may contain ItemGroup elements that may contain item elements. Die Attribute in diesem Abschnitt sind gültig, wenn sie für ein Element in einem ItemGroup angegeben werden, das ein Target ist.The attributes in this section are valid when they are specified for an item in an ItemGroup that's in a Target.

Entfernen des AttributsRemove attribute

Das Remove-Attribut entfernt bestimmte Elemente (Dateien) aus dem Elementtyp.The Remove attribute removes specific items (files) from the item type. Dieses Attribut wurde in .NET Framework 3.5 eingeführt (nur von Zielen innerhalb).This attribute was introduced in the .NET Framework 3.5 (inside targets only). Sowohl die Ziele innerhalb als auch außerhalb werden ab MSBuild 15.0 unterstützt.Both inside and outside targets are supported starting in MSBuild 15.0.

Das folgende Beispiel veranschaulicht das Entfernen aller CONFIG -Dateien aus dem Compile-Elementtyp.The following example removes every .config file from the Compile item type.

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

KeepMetadata-AttributKeepMetadata attribute

Wenn ein Element in einem Ziel erstellt wird, enthält das Item-Element möglicherweise das KeepMetadata-Attribut.If an item is generated within a target, the item element can contain the KeepMetadata attribute. 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.If this attribute is specified, only the metadata that is specified in the semicolon-delimited list of names will be transferred from the source item to the target item. Wird für dieses Attribut ein leerer Wert angegeben, ist dies, als wäre nichts angegeben worden.An empty value for this attribute is equivalent to not specifying it. Das KeepMetadata-Attribut wurde in .NET Framework 4.5 eingeführt.The KeepMetadata attribute was introduced in the .NET Framework 4.5.

Das folgende Beispiel veranschaulicht, wie das KeepMetadata-Attribut verwendet wird.The following example illustrates how to use the KeepMetadata attribute.

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

Wenn ein Element in einem Ziel erstellt wird, enthält das Item-Element möglicherweise das RemoveMetadata-Attribut.If an item is generated within a target, the item element can contain the RemoveMetadata attribute. 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.If this attribute is specified, all metadata is transferred from the source item to the target item except metadata whose names are contained in the semicolon-delimited list of names. Wird für dieses Attribut ein leerer Wert angegeben, ist dies, als wäre nichts angegeben worden.An empty value for this attribute is equivalent to not specifying it. Das RemoveMetadata-Attribut wurde in .NET Framework 4.5 eingeführt.The RemoveMetadata attribute was introduced in the .NET Framework 4.5.

Das folgende Beispiel veranschaulicht, wie das RemoveMetadata-Attribut verwendet wird.The following example illustrates how to use the RemoveMetadata attribute.

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

KeepDuplicates-AttributKeepDuplicates attribute

Wenn ein Element in einem Ziel erstellt wird, enthält das Item-Element möglicherweise das KeepDuplicates-Attribut.If an item is generated within a target, the item element can contain the KeepDuplicates attribute. 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.KeepDuplicates is a Boolean attribute that specifies whether an item should be added to the target group if the item is an exact duplicate of an existing item.

Wenn Quell- und Zielelement denselben Include-Wert, aber unterschiedliche Metadaten aufweisen, wird das Element auch dann hinzugefügt, wenn für KeepDuplicates``false festgelegt wurde.If the source and target item have the same Include value but different metadata, the item is added even if KeepDuplicates is set to false. Wird für dieses Attribut ein leerer Wert angegeben, ist dies, als wäre nichts angegeben worden.An empty value for this attribute is equivalent to not specifying it. Das KeepDuplicates-Attribut wurde in .NET Framework 4.5 eingeführt.The KeepDuplicates attribute was introduced in the .NET Framework 4.5.

Das folgende Beispiel veranschaulicht, wie das KeepDuplicates-Attribut verwendet wird.The following example illustrates how to use the KeepDuplicates attribute.

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

Aktualisieren von Metadaten für Elemente in einer ItemGroup außerhalb eines ZielsUpdating metadata on items in an ItemGroup outside of a Target

Für Elemente außerhalb von Zielen können vorhandene Metadaten über das Update-Attribut aktualisiert werden.Items outside of targets can have their existing metadata updated via the Update attribute. Dieses Attribut ist nicht für Elemente unter Zielen verfügbar.This attribute is not available for items under targets.

<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.In MSBuild version 16.6 and later, the Update attribute supports qualified metadata references to facilitate importing metadata from two or more items.

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

  • Nicht qualifizierte Metadaten (% (M)) werden an den zu aktualisierenden Elementtyp (Item1 im Beispiel oben) gebunden.Unqualified metadata (%(M)) binds to the item type being updated (Item1 in above example). Qualifizierte Metadaten (%(Item2.Color)) werden innerhalb des Satzes der erfassten übereinstimmenden Elementtypen aus dem Aktualisierungsausdruck gebunden.Qualified metadata (%(Item2.Color)) binds inside the set of captured matching item types from the Update expression.
  • Wenn ein Element mehrmals innerhalb von und zwischen mehreren referenzierten Elementen übereinstimmt:If an item matches multiple times within and between multiple referenced items:
    • Das letzte Vorkommen jedes referenzierten Elementtyps wird erfasst (also ein erfasstes Element pro Elementtyp).The last occurrence from each referenced item type gets captured (so one captured item per item type).
    • Dies entspricht dem Verhalten der Batchverarbeitung von Aufgabenelementen unter den Zielen.This matches the behaviour of task item batching under targets.
  • Hier können%()-Verweise eingefügt werden:Where one can put %() references:
    • MetadatenMetadata
    • MetadatenbedingungenMetadata conditions
  • Beim Abgleich von Metadatennamen wird nicht zwischen Groß- und Kleinschreibung unterschieden.Metadata name matching is case insensitive.

Aktualisieren von Metadaten für Elemente in einer ItemGroup eines ZielsUpdating metadata on items in an ItemGroup of a Target

Metadaten können auch in Zielen mit einer weniger ausdrucksstarken Syntax als Update geändert werden:Metadata can be modified inside targets too, by a less expressive syntax than 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:
-->

Siehe auchSee also