Ordem de construção alvo

Os alvos devem ser ordenados se a entrada para um destino depender da saída de outro destino. Você pode usar esses atributos para especificar a ordem em que os destinos são executados:

• . Este atributo especifica os destinos que serão executados primeiro, mesmo que os destinos sejam especificados na linha de comando ou no atributo.

• . Este atributo especifica quais destinos serão executados se um destino não for especificado explicitamente na linha de comando.

• . Este atributo especifica os destinos que devem ser executados antes que esse destino possa ser executado.

• e . Esses atributos especificam que esse destino deve ser executado antes ou depois dos destinos especificados.

Em geral, você não deve depender da ordem da declaração para especificar quais tarefas são executadas antes de outras tarefas.

Um destino nunca é executado duas vezes durante uma compilação, mesmo que um destino subsequente na compilação dependa dele. Uma vez que um alvo tenha sido executado, a sua contribuição para a compilação está concluída.

Os alvos podem ter um atributo. Se a condição especificada for avaliada como verdadeira, o objeto não é executado e é considerado ignorado. Consulte Determinar a ordem de construção dos alvos para detalhes sobre como os alvos saltados se comportam. Para obter mais informações sobre condições, consulte Condições.

Objetivos iniciais

O atributo do elemento Project especifica destinos que serão executados primeiro, mesmo que os destinos sejam especificados na linha de comando ou no atributo. Os alvos iniciais são normalmente usados para verificação de erros.

O valor do atributo pode ser uma lista ordenada e delimitada por ponto-e-vírgula de destinos. O exemplo a seguir especifica que o destino é executado e, em seguida, o destino é executado.

<Project InitialTargets="Warm;Eject">

Projetos importados podem ter seus próprios atributos. Todos os alvos iniciais são agregados e executados em ordem.

Para obter mais informações, consulte Como especificar qual destino criar primeiro.

Destinos padrão

O atributo do elemento Project especifica qual destino ou destinos serão criados se um destino não for especificado explicitamente em uma linha de comando.

O valor do atributo pode ser uma lista ordenada e delimitada por ponto-e-vírgula de destinos padrão. O exemplo a seguir especifica que o destino é executado e, em seguida, o destino é executado.

<Project DefaultTargets="Clean;Build">

Você pode substituir os destinos padrão usando a opção -target na linha de comando. O exemplo a seguir especifica que o destino é executado e, em seguida, o destino é executado. Quando você especifica destinos dessa maneira, todos os destinos padrão são ignorados.

msbuild -target:Build;Report

Se os destinos iniciais e os destinos padrão forem especificados, e se nenhum destino de linha de comando for especificado, o MSBuild executará os destinos iniciais primeiro e, em seguida, executará os destinos padrão.

Projetos importados podem ter seus próprios atributos. O primeiro atributo encontrado determina quais destinos padrão serão executados.

Para obter mais informações, consulte Como especificar qual destino criar primeiro.

Primeiro alvo

Se não houver destinos iniciais, destinos padrão ou destinos de linha de comando, o MSBuild executará o primeiro destino encontrado no arquivo de projeto ou em quaisquer arquivos de projeto importados.

Dependências alvo

Os alvos podem descrever relações de dependência entre si. O atributo indica que um destino depende de outros destinos. Por exemplo

<Target Name="Serve" DependsOnTargets="Chop;Cook" />

diz ao MSBuild que o alvo depende do alvo e do alvo . O MSBuild executa o destino e, em seguida, executa o destino antes de executar o destino.

BeforeTargets e AfterTargets

Você pode especificar a ordem de destino usando os atributos e .

Considere o seguinte script.

<Project DefaultTargets="Compile;Link">
    <Target Name="Compile">
        <Message Text="Compiling" />
    </Target>
    <Target Name="Link">
        <Message Text="Linking" />
    </Target>
</Project>

Para criar um destino intermediário que seja executado após o destino, mas antes do destino, adicione o seguinte destino em qualquer lugar do elemento .

<Target Name="Optimize" AfterTargets="Compile">
    <Message Text="Optimizing" />
</Target>

Como alternativa, especifique a ordem como

<Target Name="Optimize" BeforeTargets="Link">
    <Message Text="Optimizing" />
</Target>

Não é útil especificar ambos e no mesmo destino. Conforme descrito na próxima seção, apenas o primeiro alvo encontrado fará com que o novo alvo seja executado.

Determinar a ordem de construção de alvo

O MSBuild determina a ordem de compilação de destino da seguinte maneira:

1. os alvos são executados.

2. Os destinos especificados na linha de comando pela opção -target são executados. Se você não especificar destinos na linha de comando, os destinos serão executados. Se nenhum dos dois estiver presente, o primeiro destino encontrado será executado.

3. O atributo do alvo é avaliado. Se o atributo estiver presente e for avaliado como verdadeiro, o alvo não é executado e é considerado ignorado.

   Outros destinos que listam o destino condicional em ou ainda são executados na ordem prescrita, independentemente do resultado da condição.

   Observação

   Um alvo saltado não é considerado corrido. Se outro alvo mais tarde fizer a solicitação e a condição agora for avaliada como verdadeira, o alvo executará nesse ponto. No entanto, e o que já foi executado para o alvo originalmente ignorado, não volverá a ser executado.

4. Antes que o destino seja executado ou ignorado, seus destinos são executados, a menos que o atributo seja aplicado ao destino e avaliado como .

   Observação

   Um destino é considerado ignorado se não for executado porque seus itens de saída estão up-to-date (consulte compilação incremental). Essa verificação é feita pouco antes de executar as tarefas dentro do alvo e não afeta a ordem de execução dos alvos.

5. Antes de o alvo ser executado ou ignorado, qualquer outro alvo que liste o alvo num atributo é executado.

6. Antes de o destino ser executado, seu atributo e atributo são comparados. Se o MSBuild determinar que algum dos arquivos de saída está desatualizado em relação ao arquivo ou arquivos de entrada correspondentes, então o MSBuild executa o alvo. Caso contrário, o MSBuild ignora o alvo.

7. Depois que o alvo é executado ou ignorado, qualquer outro alvo que o inclua como um atributo é executado.

Conteúdo relacionado

• Objetivos