Delen via

MSBuilditems

MSBuild-items zijn invoer in het buildsysteem en vertegenwoordigen meestal bestanden (de bestanden worden opgegeven in het Include kenmerk). Items worden gegroepeerd in itemtypen op basis van hun elementnamen. Itemtypen zijn benoemde lijsten met items die kunnen worden gebruikt als parameters voor taken. De taken gebruiken de itemwaarden om de stappen van het buildproces uit te voeren.

Omdat items worden benoemd door het itemtype waartoe ze behoren, kunnen de termen 'item' en 'itemwaarde' door elkaar worden gebruikt.

Items maken in een projectbestand

U declareert items in het projectbestand als onderliggende elementen van een ItemGroup-element . Geldige itemnamen beginnen met een hoofdletter of kleine letter of onderstrepingsteken (_); geldige volgende tekens bevatten alfanumerieke tekens (letters of cijfers), onderstrepingstekens en afbreekstreepjes (-). De naam van het onderliggende element is het type item. Met Include het kenmerk van het element worden de items (bestanden) opgegeven die bij dat itemtype moeten worden opgenomen. Met de volgende XML maakt u bijvoorbeeld een itemtype met de naam Compile, dat twee bestanden bevat.

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

Het item file2.cs vervangt het item niet file1.cs; In plaats daarvan wordt de bestandsnaam toegevoegd aan de lijst met waarden voor het Compile itemtype.

Met de volgende XML wordt hetzelfde itemtype gemaakt door beide bestanden in één Include kenmerk te declareren. U ziet dat de bestandsnamen worden gescheiden door een puntkomma.

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

Het Include kenmerk is een pad dat wordt geïnterpreteerd ten opzichte van de map van het projectbestand, $(MSBuildProjectPath)zelfs als het item zich in een geïmporteerd bestand bevindt, zoals een .targets bestand.

Items maken tijdens de uitvoering

Items die buiten doelelementen vallen, worden tijdens de evaluatiefase van een build toegewezen. Tijdens de volgende uitvoeringsfase kunnen items op de volgende manieren worden gemaakt of gewijzigd:

  • Elke taak kan een item verzenden. Als u een item wilt verzenden, moet het taakelement een onderliggend uitvoerelement hebben dat een ItemName kenmerk heeft.

  • De taak CreateItem kan een item verzenden. Dit gebruik is afgeschaft.

  • Target elementen kunnen ItemGroup-elementen bevatten die itemelementen kunnen bevatten.

Verwijzingsitems in een projectbestand

Als u wilt verwijzen naar itemtypen in het projectbestand, gebruikt u de syntaxis @(ItemType). U verwijst bijvoorbeeld naar het itemtype in het vorige voorbeeld met behulp van @(Compile). Met deze syntaxis kunt u items doorgeven aan taken door het itemtype op te geven als parameter van die taak. Zie Procedures voor meer informatie : Selecteer de bestanden die u wilt bouwen.

Standaard worden de items van een itemtype gescheiden door puntkomma's (;) wanneer het wordt uitgevouwen. U kunt de syntaxis @(ItemType, 'separator') gebruiken om een ander scheidingsteken dan de standaardwaarde op te geven. Zie Instructies voor meer informatie : Een lijst met items weergeven, gescheiden door komma's.

Jokertekens gebruiken om items op te geven

U kunt de **jokertekens *en ? jokertekens gebruiken om een groep bestanden op te geven als invoer voor een build in plaats van elk bestand afzonderlijk weer te geven.

  • Het ? jokerteken komt overeen met één teken.
  • Het * jokerteken komt overeen met nul of meer tekens.
  • De ** jokertekenreeks komt overeen met een gedeeltelijk pad.

U kunt bijvoorbeeld alle .cs bestanden in de map met het projectbestand opgeven met behulp van het volgende element in het projectbestand.

<CSFile Include="*.cs"/>

Het volgende element selecteert alle .vb bestanden op het D: station:

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

Als u letterlijke * tekens of ? tekens in een item wilt opnemen zonder jokertekens uit te breiden, moet u de jokertekens escapen.

Zie Procedure voor meer informatie over jokertekens : Selecteer de bestanden die u wilt bouwen.

Het kenmerk Uitsluiten gebruiken

Itemelementen kunnen het Exclude kenmerk bevatten, dat specifieke items (bestanden) van het itemtype uitsluit. Het Exclude kenmerk wordt meestal samen met jokertekens gebruikt. Met de volgende XML wordt bijvoorbeeld elk .cs bestand in de map toegevoegd aan het CSFile itemtype, met uitzondering van het DoNotBuild.cs bestand.

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

Het Exclude kenmerk is alleen van invloed op de items die door het Include kenmerk worden toegevoegd in het itemelement dat ze beide bevat. In het volgende voorbeeld wordt het bestand niet uitgesloten Form1.cs, dat is toegevoegd in het voorgaande itemelement.

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

Zie Procedure: Bestanden uitsluiten van de build voor meer informatie.

Metagegevens van items

Items kunnen metagegevens bevatten naast de informatie in de Include en Exclude kenmerken. Deze metagegevens kunnen worden gebruikt door taken waarvoor meer informatie nodig is over de items of om taken en doelen te batcheren. Zie Batchingvoor meer informatie.

Metagegevens zijn een verzameling sleutel-waardeparen die in het projectbestand worden gedeclareerd als onderliggende elementen van een itemelement. De naam van het onderliggende element is de naam van de metagegevens en de waarde van het onderliggende element is de waarde van de metagegevens.

De metagegevens zijn gekoppeld aan het itemelement dat het bevat. Met de volgende XML worden bijvoorbeeld metagegevens toegevoegd Culture die de waarde Fr hebben voor zowel de one.cs als de two.cs items van het CSFile itemtype.

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

Een item kan nul of meer metagegevenswaarden hebben. U kunt metagegevenswaarden op elk gewenst moment wijzigen. Als u metagegevens instelt op een lege waarde, verwijdert u deze effectief uit de build.

Metagegevens van referentie-items in een projectbestand

U kunt verwijzen naar metagegevens van items in het projectbestand met behulp van de syntaxis %(ItemMetadataName). Als er dubbelzinnigheid bestaat, kunt u een verwijzing kwalificeren met behulp van de naam van het itemtype. U kunt bijvoorbeeld opgeven %(ItemType.ItemMetaDataName). In het volgende voorbeeld worden de Display metagegevens gebruikt om de Message taak te batcheren. Zie Itemmetagegevens in taakbatches voor meer informatie over het gebruik van itemmetagegevens voor batchverwerking.

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

Bekende metagegevens van items

Wanneer een item wordt toegevoegd aan een itemtype, krijgt dat item enkele bekende metagegevens toegewezen. Alle items hebben bijvoorbeeld de bekende metagegevens %(Filename), waarvan de waarde de bestandsnaam van het item is (zonder de extensie). Zie De metagegevens van bekende items voor meer informatie.

Itemtypen transformeren met behulp van metagegevens

U kunt itemlijsten omzetten in nieuwe itemlijsten met behulp van metagegevens. U kunt bijvoorbeeld een itemtype CppFiles transformeren dat items bevat die bestanden vertegenwoordigen .cpp in een bijbehorende lijst met bestanden met behulp van .obj de expressie @(CppFiles -> '%(Filename).obj').

Met de volgende code wordt een CultureResource itemtype gemaakt dat kopieën van alle EmbeddedResource items met Culture metagegevens bevat. De Culture metagegevenswaarde wordt de waarde van de nieuwe metagegevens CultureResource.TargetDirectory.

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

Zie MSBuild-itemfuncties en transformaties voor meer bewerkingen over items.

Itemdefinities

U kunt standaardmetagegevens toevoegen aan elk itemtype met behulp van het element ItemDefinitionGroup. Net als bekende metagegevens zijn de standaardmetagegevens gekoppeld aan alle items van het itemtype dat u opgeeft. U kunt standaardmetagegevens expliciet overschrijven in een itemdefinitie. De volgende XML geeft bijvoorbeeld de Compile items one.cs en three.cs de metagegevens BuildDay met de waarde Maandag. De code geeft het item two.cs de metagegevens BuildDay met de waarde 'Dinsdag'.

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

Zie Itemdefinities voor meer informatie.

Kenmerken voor items in een ItemGroup van een doel

Target elementen kunnen ItemGroup-elementen bevatten die itemelementen kunnen bevatten. De kenmerken in deze sectie zijn geldig wanneer ze worden opgegeven voor een item in een item in een ItemGroupTarget.

Kenmerk verwijderen

Het Remove kenmerk verwijdert specifieke items (bestanden) uit het itemtype. Dit kenmerk is geïntroduceerd in .NET Framework 3.5 (alleen binnen doelen). Zowel binnen- als buitendoelen worden ondersteund vanaf MSBuild 15.0.

In het volgende voorbeeld wordt elk .config bestand uit het Compile itemtype verwijderd.

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

Kenmerk MatchOnMetadata

Het MatchOnMetadata kenmerk is alleen Remove van toepassing op kenmerken die verwijzen naar andere items (bijvoorbeeld Remove="@(Compile);@(Content)") en geeft aan dat de Remove bewerking overeenkomt met items op basis van de waarden van de opgegeven metagegevensnamen, in plaats van te vergelijken op basis van de itemwaarden.

Overeenkomende regel voor B Remove="@(A)" MatchOnMetadata="M": verwijder alle items uit B die metagegevens Mbevatten, waarvan de metagegevenswaarde V voor M een item A overeenkomt met metagegevens M van waarde V.

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

In het voorbeeld worden itemwaarden b2en c2d2 items verwijderd uit het item B omdat:

  • b2en c2 van B match tegen b1 vanaf A en M1=2M2=x
  • d2 van B wedstrijden tegen c1 van A op M1=3 en M2=y

De Message taak voert het volgende uit:

  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'

Voorbeeld van gebruik van MatchOnMetadataMSBuild:

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

Met deze regel verwijdert u items _TransitiveItemsToCopyToOutputDirectory met dezelfde TargetPath metagegevenswaarden uit items in _ThisProjectItemsToCopyToOutputDirectory

Kenmerk MatchOnMetadataOptions

Hiermee geeft u de tekenreekskoppelingsstrategie op die wordt MatchOnMetadata gebruikt voor het vergelijken van de metagegevenswaarden tussen items (metagegevensnamen zijn altijd niet hoofdlettergevoelig). Mogelijke waarden zijn CaseSensitive, CaseInsensitiveof PathLike. De standaardwaarde is CaseSensitive.

PathLike past padbewuste normalisatie toe op de waarden, zoals het normaliseren van slash-oriëntaties, het negeren van afsluitende slashes, het elimineren . en .., en het maken van alle relatieve paden absoluut ten opzichte van de huidige map.

Kenmerk KeepMetadata

Als een item binnen een doel wordt gegenereerd, kan het itemelement het KeepMetadata kenmerk bevatten. Als dit kenmerk is opgegeven, worden alleen de metagegevens die zijn opgegeven in de door puntkomma's gescheiden lijst met namen overgebracht van het bronitem naar het doelitem. Een lege waarde voor dit kenmerk is gelijk aan het niet opgeven ervan. Het KeepMetadata kenmerk is geïntroduceerd in .NET Framework 4.5.

In het volgende voorbeeld ziet u hoe u het KeepMetadata kenmerk gebruikt.

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

Kenmerk RemoveMetadata

Als een item binnen een doel wordt gegenereerd, kan het itemelement het RemoveMetadata kenmerk bevatten. Als dit kenmerk is opgegeven, worden alle metagegevens van het bronitem overgebracht naar het doelitem, met uitzondering van metagegevens waarvan de namen zijn opgenomen in de door puntkomma's gescheiden lijst met namen. Een lege waarde voor dit kenmerk is gelijk aan het niet opgeven ervan. Het RemoveMetadata kenmerk is geïntroduceerd in .NET Framework 4.5.

In het volgende voorbeeld ziet u hoe u het RemoveMetadata kenmerk gebruikt.

<Project>

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

Zie MSBuild-itemfuncties voor meer bewerkingen over items.

Kenmerk KeepDuplicates

Als een item binnen een doel wordt gegenereerd, kan het itemelement het KeepDuplicates kenmerk bevatten. KeepDuplicates is een Boolean kenmerk dat aangeeft of een item moet worden toegevoegd aan de doelgroep als het item een exact duplicaat van een bestaand item is.

Als het bron- en doelitem dezelfde Include waarde maar verschillende metagegevens hebben, wordt het item toegevoegd, zelfs als KeepDuplicates het is ingesteld op false. Een lege waarde voor dit kenmerk is gelijk aan het niet opgeven ervan. Het KeepDuplicates kenmerk is geïntroduceerd in .NET Framework 4.5.

In het volgende voorbeeld ziet u hoe u het KeepDuplicates kenmerk gebruikt.

<Project>

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

Omdat het KeepDuplicates kenmerk de metagegevens van items naast de itemwaarden beschouwt, is het belangrijk om te weten wat er gebeurt met de metagegevens. Zie Bijvoorbeeld Duplicaten detecteren wanneer u de functie Metagegevensitem gebruikt.

Metagegevens bijwerken voor items in een ItemGroup buiten een doel

Items buiten doelen kunnen hun bestaande metagegevens worden bijgewerkt via het Update kenmerk. Dit kenmerk is niet beschikbaar voor items onder doelen.

<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 versie 16.6 en hoger ondersteunt het Update kenmerk gekwalificeerde metagegevensverwijzingen om het importeren van metagegevens uit twee of meer items te vergemakkelijken.

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

Opmerkingen:

  • Niet-gekwalificeerde metagegevens (%(MetadataName)) binden aan het itemtype dat wordt bijgewerkt (Item1 in het bovenstaande voorbeeld). Gekwalificeerde metagegevens (%(Item2.Color)) binden binnen de set vastgelegde overeenkomende itemtypen uit de Update-expressie.
  • Als een item meerdere keren binnen en tussen meerdere items waarnaar wordt verwezen, overeenkomt:
    • De laatste instantie van elk itemtype waarnaar wordt verwezen, wordt vastgelegd (dus één vastgelegd item per itemtype).
    • Dit komt overeen met het gedrag van batchverwerking van taakitems onder doelen.
  • Waar men %() verwijzingen kan plaatsen:
    • Metagegevens
    • Voorwaarden voor metagegevens
  • Naam van metagegevens komt niet hoofdlettergevoelig overeen.

Metagegevens bijwerken voor items in een ItemGroup van een doel

Metagegevens kunnen ook binnen doelen worden gewijzigd door een minder expressieve syntaxis dan 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:
-->

Verwante inhoud

  • Last updated on