Položky nástroje MSBuildMSBuild items

Položky nástroje MSBuild jsou vstupy do systému sestavení a obvykle představují soubory (soubory jsou zadány v Include atributu).MSBuild items are inputs into the build system, and they typically represent files (the files are specified in the Include attribute). Položky jsou seskupeny do typů položek na základě jejich názvů prvků.Items are grouped into item types based on their element names. Typy položek jsou pojmenované seznamy položek, které lze použít jako parametry pro úlohy.Item types are named lists of items that can be used as parameters for tasks. Úkoly používají hodnoty položek k provedení kroků procesu sestavení.The tasks use the item values to perform the steps of the build process.

Vzhledem k tomu, že položky jsou pojmenovány typem položky, ke kterým patří, je možné použít "položku" a "hodnotu položky", které jsou zaměnitelné.Because items are named by the item type to which they belong, the terms "item" and "item value" can be used interchangeably.

Vytvoření položek v souboru projektuCreate items in a project file

Položky v souboru projektu deklarujete jako podřízené prvky elementu ItemCollection .You declare items in the project file as child elements of an ItemGroup element. Název podřízeného prvku je typ položky.The name of the child element is the type of the item. IncludeAtribut elementu určuje položky (soubory), které mají být zahrnuty do daného typu položky.The Include attribute of the element specifies the items (files) to be included with that item type. Například následující kód XML vytvoří typ položky s názvem Compile , který obsahuje dva soubory.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>

Položka File2.cs nenahrazuje položku FILE1.cs ; místo toho se název souboru připojí k seznamu hodnot pro daný Compile typ položky.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.

Následující kód XML vytvoří stejný typ položky deklarováním obou souborů v jednom Include atributu.The following XML creates the same item type by declaring both files in one Include attribute. Všimněte si, že názvy souborů jsou oddělené středníkem.Notice that the file names are separated by a semicolon.

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

IncludeAtribut je cesta, která je interpretována relativně ke složce souboru projektu $ (MSBuildProjectPath), a to i v případě, že je položka v importovaném souboru, jako je například soubor . targets .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.

Během provádění vytvořit položkyCreate items during execution

K položkám, které jsou mimo cílové prvky, jsou přiřazeny hodnoty během fáze hodnocení sestavení.Items that are outside Target elements are assigned values during the evaluation phase of a build. Během následné fáze provádění lze položky vytvořit nebo upravit následujícími způsoby:During the subsequent execution phase, items can be created or modified in the following ways:

  • Libovolný úkol může vygenerovat položku.Any task can emit an item. Chcete-li vygenerovat položku, musí mít element Task podřízený element Output , který má ItemName atribut.To emit an item, the Task element must have a child Output element that has an ItemName attribute.

  • Úkol CreateItem – může vygenerovat položku.The CreateItem task can emit an item. Tento způsob využití je zastaralý.This usage is deprecated.

  • Počínaje .NET Framework 3,5 Target prvky mohou obsahovat prvky položky , které mohou obsahovat prvky položky.Starting in the .NET Framework 3.5, Target elements may contain ItemGroup elements that may contain item elements.

Referenční položky v souboru projektuReference items in a project file

Chcete-li odkazovat na typy položek v celém souboru projektu, použijte syntaxi @ ( <ItemType> ).To reference item types throughout the project file, you use the syntax @(<ItemType>). Například byste odkazovali na typ položky v předchozím příkladu pomocí @(Compile) .For example, you would reference the item type in the previous example by using @(Compile). Pomocí této syntaxe můžete předat položky úkolů zadáním typu položky jako parametru této úlohy.By using this syntax, you can pass items to tasks by specifying the item type as a parameter of that task. Další informace najdete v tématu Postupy: výběr souborů pro sestavení.For more information, see How to: Select the files to build.

Ve výchozím nastavení jsou položky typu položky oddělené středníky (;) Když je rozbalený.By default, the items of an item type are separated by semicolons (;) when it's expanded. Můžete použít syntaxi @ ( <ItemType> , ' <separator> ') k určení oddělovače, který je jiný než výchozí.You can use the syntax @(<ItemType>, '<separator>') to specify a separator other than the default. Další informace najdete v tématu Postup: zobrazení seznamu položek oddělených čárkami.For more information, see How to: Display an item list separated with commas.

Zadání položek pomocí zástupných znakůUse wildcards to specify items

** * Zástupné znaky, a můžete použít ? k určení skupiny souborů jako vstupů pro sestavení místo výpisu každého souboru samostatně.You can use the **, *, and ? wildcard characters to specify a group of files as inputs for a build instead of listing each file separately.

  • ?Zástupný znak odpovídá jednomu znaku.The ? wildcard character matches a single character.
  • *Zástupný znak odpovídá žádnému nebo více znakům.The * wildcard character matches zero or more characters.
  • **Sekvence zástupných znaků odpovídá částečné cestě.The ** wildcard character sequence matches a partial path.

Například můžete zadat všechny .cs soubory v adresáři, který obsahuje soubor projektu, pomocí následujícího elementu v souboru projektu.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"/>

Následující prvek vybere všechny .vb soubory na D: jednotce:The following element selects all .vb files on the D: drive:

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

Chcete-li zahrnout literály * nebo ? znaky do položky bez rozšíření zástupných znaků, je nutné řídicí znaky escape.If you would like to include literal * or ? characters in an item without wildcard expansion, you must escape the wildcard characters.

Další informace o zástupných znacích naleznete v tématu How to: vyberte soubory, které chcete sestavit.For more information about wildcard characters, see How to: Select the files to build.

Použití atributu ExcludeUse the Exclude attribute

Prvky položky mohou obsahovat Exclude atribut, který vylučuje konkrétní položky (soubory) z typu položky.Item elements can contain the Exclude attribute, which excludes specific items (files) from the item type. ExcludeAtribut se obvykle používá společně se zástupnými znaky.The Exclude attribute is typically used together with wildcard characters. Například následující kód XML přidá každý soubor . cs v adresáři do typu položky CSFile s výjimkou souboru DoNotBuild.cs .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>

ExcludeAtribut ovlivňuje pouze položky, které jsou přidány Include atributem v prvku Item, který je obsahuje obě.The Exclude attribute affects only the items that are added by the Include attribute in the item element that contains them both. Následující příklad nevylučuje soubor Form1.cs , který byl přidán do předchozí položky elementu.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">

Další informace najdete v tématu Postup: vyloučení souborů ze sestavení.For more information, see How to: Exclude files from the build.

Metadata položkyItem metadata

Kromě informací v atributech a můžou položky obsahovat i metadata Include Exclude .Items may contain metadata in addition to the information in the Include and Exclude attributes. Tato metadata mohou být používána úkoly, které vyžadují další informace o položkách nebo úlohách a cílech Batch.This metadata can be used by tasks that require more information about the items or to batch tasks and targets. Další informace najdete v tématu dávkování.For more information, see Batching.

Metadata je kolekce párů klíč-hodnota, které jsou deklarovány v souboru projektu jako podřízené prvky elementu Item.Metadata is a collection of key-value pairs that are declared in the project file as child elements of an item element. Název podřízeného prvku je název metadat a hodnota podřízeného elementu je hodnota metadat.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.

Metadata jsou přidružena k elementu Item, který jej obsahuje.The metadata is associated with the item element that contains it. Například následující kód XML přidá Culture metadata, která mají hodnotu Fr pro One.cs a Two.cs položky typu položky CSFile.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>

Položka může mít nula nebo více hodnot metadat.An item can have zero or more metadata values. Hodnoty metadat můžete kdykoli změnit.You can change metadata values at any time. Pokud nastavíte metadata na prázdnou hodnotu, můžete ji efektivně odebrat ze sestavení.If you set metadata to an empty value, you effectively remove it from the build.

Metadata položky reference v souboru projektuReference item metadata in a project file

Metadata položky můžete odkazovat v celém souboru projektu pomocí syntaxe%( <ItemMetadataName> ).You can reference item metadata throughout the project file by using the syntax %(<ItemMetadataName>). Pokud existuje nejednoznačnost, můžete kvalifikovat odkaz pomocí názvu typu položky.If ambiguity exists, you can qualify a reference by using the name of the item type. Můžete například zadat%( <ItemType.ItemMetaDataName> ). Následující příklad používá metadata zobrazení k dávkování úlohy zprávy.For example, you can specify %(<ItemType.ItemMetaDataName>).The following example uses the Display metadata to batch the Message task. Další informace o tom, jak používat metadata položek pro dávkování, najdete v tématu Metadata položek v dávkování úloh.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>

Dobře známá metadata položkyWell-known item metadata

Když je položka přidána do typu položky, je tato položka přiřazena dobře známým metadatům.When an item is added to an item type, that item is assigned some well-known metadata. Například všechny položky mají dobře známé metadata%( <Filename> ), jehož hodnota je název souboru položky (bez přípony).For example, all items have the well-known metadata %(<Filename>), whose value is the file name of the item (without the extension). Další informace najdete v tématu známá metadata položek.For more information, see Well-known item metadata.

Transformace typů položek pomocí metadatTransform item types by using metadata

Seznamy položek můžete transformovat do seznamů nové položky pomocí metadat.You can transform item lists into new item lists by using metadata. Například můžete převést typ položky CppFiles , který obsahuje položky, které reprezentují soubory . cpp , do odpovídajícího seznamu souborů . obj pomocí výrazu @(CppFiles -> '%(Filename).obj') .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').

Následující kód vytvoří CultureResource typ položky, který obsahuje kopie všech EmbeddedResource položek s Culture metadaty.The following code creates a CultureResource item type that contains copies of all EmbeddedResource items with Culture metadata. CultureHodnota metadata se zobrazí jako hodnota nových metadat 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>

Další informace najdete v tématu transformace.For more information, see Transforms.

Definice položekItem definitions

Počínaje .NET Framework 3,5 můžete přidat výchozí metadata k libovolnému typu položky pomocí elementu ItemDefinitionGroup.Starting in the .NET Framework 3.5, you can add default metadata to any item type by using the ItemDefinitionGroup element. Podobně jako dobře známá metadata jsou výchozí metadata přidružena ke všem položkám typu položky, které zadáte.Like well-known metadata, the default metadata is associated with all items of the item type that you specify. Výchozí metadata můžete explicitně přepsat v definici položky.You can explicitly override default metadata in an item definition. Například následující kód XML poskytuje Compile položky one.cs a Three.cs metadata BuildDay s hodnotou "pondělí".For example, the following XML gives the Compile items one.cs and three.cs the metadata BuildDay with the value "Monday". Kód umožňuje, aby položka Two.cs metadata BuildDay s hodnotou "úterý".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>

Další informace naleznete v tématu Definice položek.For more information, see Item definitions.

Atributy pro položky v instanci položky cíleAttributes for items in an ItemGroup of a Target

Počínaje .NET Framework 3,5 Target prvky mohou obsahovat prvky položky , které mohou obsahovat prvky položky.Starting in the .NET Framework 3.5, Target elements may contain ItemGroup elements that may contain item elements. Atributy v této části jsou platné, pokud jsou zadány pro položku v objektu ItemGroup , který je v Target .The attributes in this section are valid when they are specified for an item in an ItemGroup that's in a Target.

Odebrat atributRemove attribute

RemoveAtribut odebere konkrétní položky (soubory) z typu položky.The Remove attribute removes specific items (files) from the item type. Tento atribut byl představen v .NET Framework 3,5 (pouze uvnitř cílů).This attribute was introduced in the .NET Framework 3.5 (inside targets only). V MSBuild 15,0 jsou podporovány jak uvnitř, tak mimo cíle.Both inside and outside targets are supported starting in MSBuild 15.0.

Následující příklad odebere každý soubor . config z typu položky kompilace.The following example removes every .config file from the Compile item type.

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

KeepMetadata – atributKeepMetadata attribute

Pokud je položka generována v rámci cíle, element Item může KeepMetadata atribut obsahovat.If an item is generated within a target, the item element can contain the KeepMetadata attribute. Pokud je tento atribut zadán, budou ze zdrojové položky do cílové položky přenesena pouze metadata, která jsou zadána v seznamu názvů oddělených středníkem.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. Prázdná hodnota pro tento atribut je ekvivalentní s jeho zadáním.An empty value for this attribute is equivalent to not specifying it. KeepMetadataAtribut byl představen v .NET Framework 4,5.The KeepMetadata attribute was introduced in the .NET Framework 4.5.

Následující příklad ukazuje, jak použít KeepMetadata atribut.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 – atributRemoveMetadata attribute

Pokud je položka generována v rámci cíle, element Item může RemoveMetadata atribut obsahovat.If an item is generated within a target, the item element can contain the RemoveMetadata attribute. Je-li tento atribut zadán, jsou všechna metadata přenesena ze zdrojové položky do cílové položky s výjimkou metadat, jejichž názvy jsou obsaženy v seznamu názvů oddělených středníkem.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. Prázdná hodnota pro tento atribut je ekvivalentní s jeho zadáním.An empty value for this attribute is equivalent to not specifying it. RemoveMetadataAtribut byl představen v .NET Framework 4,5.The RemoveMetadata attribute was introduced in the .NET Framework 4.5.

Následující příklad ukazuje, jak použít RemoveMetadata atribut.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 – atributKeepDuplicates attribute

Pokud je položka generována v rámci cíle, element Item může KeepDuplicates atribut obsahovat.If an item is generated within a target, the item element can contain the KeepDuplicates attribute. KeepDuplicates je Boolean atribut, který určuje, zda má být položka přidána do cílové skupiny, pokud je položka přesným duplikátem existující položky.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.

Pokud má zdrojová a cílová položka stejnou hodnotu zahrnutí, ale odlišná metadata, položka je přidána i v případě, že KeepDuplicates je nastavena na false .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. Prázdná hodnota pro tento atribut je ekvivalentní s jeho zadáním.An empty value for this attribute is equivalent to not specifying it. KeepDuplicatesAtribut byl představen v .NET Framework 4,5.The KeepDuplicates attribute was introduced in the .NET Framework 4.5.

Následující příklad ukazuje, jak použít KeepDuplicates atribut.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
-->

Aktualizace metadat u položek v instanci položky mimo cílUpdating metadata on items in an ItemGroup outside of a Target

V položkách mimo cílů mohou být jejich existující metadata aktualizována prostřednictvím Update atributu.Items outside of targets can have their existing metadata updated via the Update attribute. Tento atribut není k dispozici pro položky, které jsou v cíli.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
-->

V MSBuild verze 16,6 a novější Update atribut podporuje kvalifikované odkazy metadat, které usnadňují import metadat ze dvou nebo více položek.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
-->

MarkRemarks:

  • Nekvalifikovaná metadata (% (M)) se váže k aktualizovanému typu položky ( Item1 v předchozím příkladu).Unqualified metadata (%(M)) binds to the item type being updated (Item1 in above example). Kvalifikovaná metadata ( %(Item2.Color) ) vytvoří vazby uvnitř sady zachycených typů položek z výrazu Update.Qualified metadata (%(Item2.Color)) binds inside the set of captured matching item types from the Update expression.
  • Pokud se položka v rámci a mezi více odkazovanými položkami shoduje vícekrát:If an item matches multiple times within and between multiple referenced items:
    • Bude zaznamenán poslední výskyt z každého odkazovaného typu položky (takže jednu zachycenou položku na typ položky).The last occurrence from each referenced item type gets captured (so one captured item per item type).
    • To odpovídá chování při dávkování položek úkolu v rámci cílů.This matches the behaviour of task item batching under targets.
  • Kde může%() odkazy na jeden z těchto umístění:Where one can put %() references:
    • MetadataMetadata
    • Podmínky metadatMetadata conditions
  • Porovnávání názvů metadat rozlišuje velká a malá písmena.Metadata name matching is case insensitive.

Aktualizace metadat u položek ve vlastnictví položky v cíliUpdating metadata on items in an ItemGroup of a Target

Metadata je možné upravovat i uvnitř cílů, méně výraznou syntaxí, než Update :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:
-->

Viz takéSee also