Itens do MSBuild

Artigo
02/25/2013

Os itens do MSBuild são entradas no sistema de compilação, e representam normalmente arquivos.Os itens são agrupados baseados nos tipos de itens em seus nomes de elementos.os tipos de item são nomeados listas de itens que podem ser usados como parâmetros para tarefas.As tarefas usam os valores de item para executar as etapas do processo de compilação.

Como os itens são chamados pelo tipo de item que pertencem, os termos “item” e “valor” item podem ser usados de forma intercambiável.

Neste tópico

criando itens em um projeto Arquivo
criando itens durante a execução
referenciando itens em um projeto Arquivo
Usando caracteres curinga para especificar itens
Usando o atributo de exclusão
Metadados de item
- Referenciando metadados do item em um projeto Arquivo
- Metadados conhecidos de item
- transformando tipos de item usando metadados
Definições de item
atributos para itens em um ItemGroup de um destino
- Remova o atributo
- atributo de KeepMetadata
- atributo de RemoveMetadata
- atributo de KeepDuplicates

criando itens em um projeto Arquivo

Você declara itens no arquivo de projeto como elementos filhos de um elemento de ItemGroup .O nome do elemento filho é o tipo de item.O atributo de Include do elemento especifica os itens (arquivos) a serem incluídos com esse tipo de item.Por exemplo, o XML a seguir cria um tipo de item que é chamado Compile, que inclui dois arquivos.

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

O item “file2.cs” não substitui o item file1.cs”; “ em vez de isso, o nome de arquivo é acrescentado à lista de valores para o tipo de item de Compile .Você não pode remover um item de um tipo de item durante a fase de avaliação de uma construção.

O XML a seguir cria o mesmo tipo de item declarando ambos os arquivos em um atributo de Include .Observe que os nomes de arquivo são separadas por ponto-e-vírgula.

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

criando itens durante a execução

Itens que são elementos fora de Destino são atribuídos valores durante a fase de avaliação de uma construção.Durante a fase de execução subseqüente, itens podem ser criados ou modificado das seguintes maneiras:

Qualquer tarefa pode emitir um item.Para emitir um item, o elemento de tarefa deve ter um elemento filho de Saída que tem um atributo de ItemName .
A tarefa de CreateItem pode emitir um item.Esse uso é substituído.
Iniciando no .NET Framework 3,5, os elementos de Target podem conter elementos de ItemGroup que podem conter elementos de item.

referenciando itens em um projeto Arquivo

Para referenciar tipos de itens em todo o arquivo de projeto, você usa a sintaxe @ (ItemType).Por exemplo, você faria o tipo de item no exemplo anterior usando @(Compile).Usando esta sintaxe, você pode passar itens para tarefas especificando o tipo de item como um parâmetro da tarefa.Para obter mais informações, consulte Como: selecione os arquivos para compilação.

Por padrão, os itens de um tipo de item são separadas por ponto-e-vírgula (;) quando expanda.Você pode usar a sintaxe @ (ItemType,separador“") para especificar um separador diferente do padrão.Para obter mais informações, consulte Como: exibir uma lista de itens separada por vírgulas.

Usando caracteres curinga para especificar itens

você pode usar **, *, e?caracteres curinga para especificar um grupo de arquivos como entradas de uma compilação em vez de cada arquivo listar separadamente.

?o caractere curinga corresponde a um caractere único.
* O caractere curinga corresponde zero ou mais caracteres.
** A seqüência de caracteres curinga corresponde a um caminho parcial.

Por exemplo, você pode especificar todos os arquivos .cs no diretório que contém o arquivo de projeto usando o seguinte elemento no arquivo de projeto.

<CSFile Include="*.cs"/>

O seguinte elemento selecionar todos os arquivos .vb De o: unidade:

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

Para obter mais informações sobre os caracteres curinga, consulte Como: selecione os arquivos para compilação.

Usando o atributo de exclusão

Os elementos de item podem conter o atributo de Exclude , que exclui itens específicos (arquivos) do tipo de item.O atributo de Exclude é normalmente usado junto com caracteres curinga.Por exemplo, o XML a seguir adiciona cada arquivo .cs o diretório para o tipo de item de CSFile, a não ser que o arquivo de DoNotBuild.cs .

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

O atributo de Exclude afeta apenas os itens que são adicionados pelo atributo no elemento de Include de item que os contém ambos.O exemplo não excluiria o arquivo Form1.cs, que foi adicionado no elemento acima do item.

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

Para obter mais informações, consulte Como: excluir arquivos da compilação.

Metadados de item

Itens podem conter metadados além de informações sobre os atributos de Include e de Exclude .Esses metadados podem ser usados pelas tarefas que exigem mais informações sobre os itens ou em lotes tarefas e destino.Para obter mais informações, consulte Processamento em lotes do MSBuild.

Os metadados são uma coleção de pares chave-valor que são declarados no arquivo de projeto como elementos filhos de um elemento de item.O nome do elemento filho é o nome de metadados, e o valor do elemento filho é o valor de metadados.

Os metadados são associados com o elemento do item que o contém.Por exemplo, o XML a seguir adiciona metadados de Culture que tem o valor Fr “one.cs” e itens de “two.cs” do tipo de item de CSFile.

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

Um item pode ter zero ou mais valores de metadados.Você pode alterar valores de metadados para qualquer momento.Se você metadados definidas como um valor vazio, você efetivamente o remove de compilação.

Referenciando metadados do item em um projeto Arquivo

Você pode referenciar metadados do item em todo o arquivo de projeto usando a sintaxeItemMetadataName(%).Se a ambigüidade existir, você pode qualificar uma referência usando o nome do tipo de item.Por exemplo, você pode especificarItemType.ItemMetaDataName(%). O seguinte exemplo usa os metadados de exibição para em lotes a tarefa de mensagem.Para obter mais informações sobre como usar metadados de item para em lotes, consulte Metadados de item em lotes de tarefa.

<Project xmlns="https://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>

Metadados conhecidos de item

Quando um item é adicionado a um tipo de item, o item é atribuído alguns metadados conhecidos.Por exemplo, todos os itens têm metadados conhecidos %(Filename), cujo valor é o nome de arquivo do item.Para obter mais informações, consulte MSBuild bem conhecidas metadados de Item.

transformando tipos de item usando metadados

Você pode transformar listas de itens em novos listas de item usando metadados.Por exemplo, você pode transformar um tipo de item CppFiles que tem itens que representam arquivos de .cpp em uma lista correspondente de arquivos de .obj usando a expressão @(CppFiles -> '%(Filename).obj').

O código a seguir cria um tipo de item de CultureResource que contém cópias de todos os itens de EmbeddedResource com metadados de Culture .O valor de metadados de Culture será o valor dos metadados CultureResource.TargetDirectory.

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

Para obter mais informações, consulte Transformações do MSBuild.

Definições de item

Iniciando no .NET Framework 3,5, você pode adicionar metadados padrão para qualquer tipo de item usando elemento de ItemDefinitionGroup.Conhecidos como metadados, os metadados padrão são associados com todos os itens de tipo de item que você especificar.Você pode explicitamente substituir os metadados padrão em uma definição de item.Por exemplo, o seguinte XML fornece os itens “one.cs” e “three.cs” de Compile os metadados BuildDay com o valor “segunda-feira”.O código faz ao item “two.cs” os metadados BuildDay com o valor”. “terça-feira

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

Para obter mais informações, consulte Definições de item.

atributos para itens em um ItemGroup de um destino

Iniciando no .NET Framework 3,5, os elementos de Target podem conter elementos de ItemGroup que podem conter elementos de item.Os atributos em esta seção são válidos quando são especificados para um item em ItemGroup que está em Target.

Remova o atributo

Os itens em ItemGroup de um destino podem conter o atributo de Remove , que remove itens específicos (arquivos) do tipo de item.Este atributo foi introduzido no .NET Framework 3,5.

O exemplo a seguir remove cada arquivo .config de tipo de item compilar.

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

atributo de KeepMetadata

Se um item é gerado em um destino, o elemento de item pode conter o atributo de KeepMetadata .Se esse atributo é especificado, somente os metadados que é especificado na lista delimitada por ponto-e-vírgula nomes de serão transferidos de item de origem ao item de destino.Um valor vazio para este atributo não é equivalente ao especificar.O atributo de KeepMetadata foi introduzido no .NET Framework 4,5.

O exemplo a seguir ilustra como usar o atributo de KeepMetadata .

<Project xmlns="https://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: 
-->

atributo de RemoveMetadata

Se um item é gerado em um destino, o elemento de item pode conter o atributo de RemoveMetadata .Se esse atributo for especificado, todos os metadados são transferidos de item de origem ao item de destino exceto os metadados cujos nomes estão contidos na lista delimitada por ponto-e-vírgula nomes de.Um valor vazio para este atributo não é equivalente ao especificar.O atributo de RemoveMetadata foi introduzido no .NET Framework 4,5.

O exemplo a seguir ilustra como usar o atributo de RemoveMetadata .

<Project ToolsVersion="4.0" xmlns="https://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: 
-->

atributo de KeepDuplicates

Se um item é gerado em um destino, o elemento de item pode conter o atributo de KeepDuplicates .KeepDuplicates é um atributo de Boolean que especifica se um item deve ser adicionado a grupo-alvo se o item é uma cópia exata de um item existente.

Se o item de origem e de destino tem o mesmo colocar o valor mas metadados diferentes, o item é adicionado mesmo se KeepDuplicates é definido como false.Um valor vazio para este atributo não é equivalente ao especificar.O atributo de KeepDuplicates foi introduzido no .NET Framework 4,5.

O exemplo a seguir ilustra como usar o atributo de KeepDuplicates .

<Project ToolsVersion="4.0" xmlns="https://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
-->

Consulte também

Compartilhar via