Compartilhar via


Criar uma tarefa embutida

As tarefas do MSBuild normalmente são criadas ao compilar uma classe que implementa a interface ITask. A partir do .NET Framework versão 4, você pode criar tarefas embutidas no arquivo de projeto. Você não precisa criar um assembly separado para hospedar a tarefa. Para saber mais, confira Tarefas embutidas.

Este passo a passo mostra como criar e executar essas tarefas embutidas:

  • Uma tarefa que não tem nenhum parâmetro de entrada ou saída.

  • Uma tarefa que não tem nenhum parâmetro de entrada e nenhum parâmetro de saída.

  • Uma tarefa que tem dois parâmetros de entrada e um parâmetro de saída que retorna uma propriedade MSBuild.

  • Uma tarefa que tem dois parâmetros de entrada e um parâmetro de saída que retorna um item MSBuild.

Para criar e executar as tarefas, use o Visual Studio e a janela de prompt de comando do Visual Studio, da seguinte maneira:

  1. Criae um arquivo de projeto do MSBuild usando o Visual Studio.

  2. Modifique o arquivo de projeto no Visual Studio para criar a tarefa embutida.

  3. Use a Janela de Prompt de Comando para compilar o projeto e examinar os resultados.

Criar e modificar um projeto do MSBuild

O sistema de projetos do Visual Studio é baseado no MSBuild. Portanto, você pode criar um arquivo de projeto de build usando o Visual Studio. Nesta seção, você criará um arquivo de projeto do Visual C#. (Em vez disso, você pode criar um arquivo de projeto do Visual Basic. No contexto deste tutorial, a diferença entre os dois arquivos de projeto é secundária.)

Para criar e modificar um arquivo de projeto

  1. No Visual Studio, crie um projeto usando o modelo de aplicativo do Windows Forms de C#. Na caixa Nome, digite InlineTasks. Digite um Local para a solução; por exemplo, D:. Certifique-se de que Criar diretório para a solução está selecionado, Adicionar ao Controle do Código-Fonte não está marcado e que Nome da Solução é InlineTasks.

  2. Clique em OK para criar o arquivo de projeto.

  3. No Gerenciador de Soluções, clique com o botão direito do mouse no nó do projeto InlineTasks e clique em Descarregar Projeto.

  4. Clique com o botão direito do mouse no nó de projeto novamente e clique em Editar InlineTasks.csproj.

    O arquivo de projeto aparecerá no editor de códigos.

Adicionar uma tarefa básica Hello

Agora, adicione ao arquivo de projeto uma tarefa básica que exiba a mensagem "Olá, mundo!". Adicione também um destino TestBuild padrão para invocar a tarefa.

Para adicionar uma tarefa básica Hello

  1. Na no nó raiz Project, altere o atributo DefaultTargets para TestBuild. O nó Project resultante deve ser semelhante a este exemplo:

    <Project ToolsVersion="4.0" DefaultTargets="TestBuild" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    
  2. Adicione a seguinte tarefa embutida e o seguinte destino ao arquivo de projeto, imediatamente antes da marca </Project>.

    <UsingTask TaskName="Hello" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll" >
      <ParameterGroup />
      <Task>
        <Code Type="Fragment" Language="cs">
          Log.LogMessage(MessageImportance.High, "Hello, world!");
        </Code>
      </Task>
    </UsingTask>
    <Target Name="TestBuild">
      <Hello />
    </Target>
    
  3. Salve o arquivo de projeto.

    Esse código cria uma tarefa embutida chamada Olá e não tem parâmetros, referências nem diretivas de Using. A tarefa Olá contém apenas uma linha de código, que exibe uma mensagem de saudação do dispositivo de registro em log padrão, normalmente a janela do console.

Executar a tarefa Hello

Execute o MSBuild com a janela Prompt de comando para construir a tarefa Olá e processar o destino TestBuild que a invoca.

Para executar a tarefa Olá
  1. Clique em Iniciar, clique em Todos os Programas e, em seguida, localize a pasta Ferramentas do Visual Studio e clique em Prompt de Comando do Visual Studio.

  2. Na janela do prompt de comando, localize a pasta que contém o arquivo de projeto. Neste caso, D:\InlineTasks\InlineTasks.

  3. Digite msbuild, sem opções de comando e pressione Enter. Por padrão, isso cria o arquivo InlineTasks.csproj e processa o TestBuild de destino padrão, que chama a tarefa Hello.

  4. Examine a saída na janela do Prompt de Comando. Você deverá ver esta linha:

    Hello, world!

    Observação

    Se você não vir a mensagem de saudação, tente salvar o arquivo de projeto novamente e, em seguida, execute a tarefa de Olá.

    Ao alternar entre o editor de códigos e a janela do Prompt de Comando, você poderá alterar o arquivo de projeto e ver os resultados rapidamente.

Definir a tarefa Echo

Crie uma tarefa embutida que aceita um parâmetro de cadeia de caracteres e exibe a cadeia de caracteres no dispositivo de registro em log padrão.

Para definir a tarefa Echo

  1. No editor de código, substitua a tarefa Olá e o destino TestBuild usando o código a seguir.

    <UsingTask TaskName="Echo" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll" >
      <ParameterGroup>
        <Text Required="true" />
      </ParameterGroup>
      <Task>
        <Code Type="Fragment" Language="cs">
          Log.LogMessage(MessageImportance.High, Text);
        </Code>
      </Task>
    </UsingTask>
    <Target Name="TestBuild">
      <Echo Text="Greetings!" />
    </Target>
    
  2. Na janela do Prompt de Comando, digite msbuild sem opções de comando e pressione Enter. Por padrão, isso processa o TestBuild de destino padrão, que invoca a tarefa Echo.

  3. Examine a saída na janela do Prompt de Comando. Você deverá ver esta linha:

    Greetings!

    Esse código define uma tarefa embutida chamada Echo e tem apenas um parâmetro de entrada Text necessário. Por padrão, os parâmetros são do tipo System.String. O valor do parâmetro Text é definido quando o destino TestBuild invoca a tarefa de Echo.

Definir a tarefa Adder

Crie uma tarefa embutida que adiciona dois parâmetros inteiros e emite sua soma como uma propriedade de MSBuild.

Para definir a tarefa Adder

  1. No editor de código, substitua a tarefa Echo e o destino TestBuild usando o código a seguir.

    <UsingTask TaskName="Adder" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll" >
      <ParameterGroup>
        <A ParameterType="System.Int32" Required="true" />
        <B ParameterType="System.Int32" Required="true" />
        <C ParameterType="System.Int32" Output="true" />
      </ParameterGroup>
      <Task>
        <Code Type="Fragment" Language="cs">
          C = A + B;
        </Code>
      </Task>
    </UsingTask>
    <Target Name="TestBuild">
      <Adder A="4" B="5">
        <Output PropertyName="Sum" TaskParameter="C" />
      </Adder>
      <Message Text="The sum is $(Sum)" Importance="High" />
    </Target>
    
  2. Na janela do Prompt de Comando, digite msbuild sem opções de comando e pressione Enter. Por padrão, isso processa o TestBuild de destino padrão, que invoca a tarefa Echo.

  3. Examine a saída na janela do Prompt de Comando. Você deverá ver esta linha:

    The sum is 9

    Esse código define uma tarefa embutida chamada Adder e tem dois parâmetros necessários de entrada de inteiro, A e B, além de um parâmetro de saída inteiro, C. A tarefa adicionador adiciona dois parâmetros de entrada e retorna a soma no parâmetro de saída. A soma é emitida como a propriedade Sum do MSBuild. Os valores dos parâmetros de entrada são definidos quando o destino TestBuild invoca a tarefa Adder.

Definir a tarefa RegX

Crie uma tarefa embutida que aceite um grupo de itens e uma expressão regular e retorne uma lista de todos os itens que tenham conteúdo do arquivo que corresponda à expressão.

Para definir a tarefa RegX

  1. No editor de código, substitua a tarefa Adder e o destino TestBuild usando o código a seguir.

    <UsingTask TaskName="RegX" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll" >
      <ParameterGroup>
        <Expression Required="true" />
        <Files ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="true" />
        <Result ParameterType="Microsoft.Build.Framework.ITaskItem[]" Output="true" />
      </ParameterGroup>
      <Task>
        <Using Namespace="System.Text.RegularExpressions"/>
        <Code Type="Fragment" Language="cs">
    <![CDATA[
          if (Files.Length > 0)
          {
            Result = new TaskItem[Files.Length];
            for (int i = 0; i < Files.Length; i++)
            {
              ITaskItem item = Files[i];
              string path = item.GetMetadata("FullPath");
              using(StreamReader rdr = File.OpenText(path))
              {
                if (Regex.Match(rdr.ReadToEnd(), Expression).Success)
                {
                  Result[i] = new TaskItem(item.ItemSpec);
                }
              }
            }
          }
    ]]>
        </Code>
      </Task>
    </UsingTask>
    <Target Name="TestBuild">
      <RegX Expression="public|protected" Files="@(Compile)">
        <Output ItemName="MatchedFiles" TaskParameter="Result" />
      </RegX>
      <Message Text="Input files: @(Compile)" Importance="High" />
      <Message Text="Matched files: @(MatchedFiles)" Importance="High" />
    </Target>
    
  2. Na janela do Prompt de Comando, digite msbuild sem opções de comando e pressione Enter. Por padrão, isso processa o TestBuild de destino padrão, que invoca a tarefa RegX.

  3. Examine a saída na janela do Prompt de Comando. Você deverá ver estas linhas:

    Input files: Form1.cs;Form1.Designer.cs;Program.cs;Properties\AssemblyInfo.cs;Properties\Resources.Designer.cs;Properties\Settings.Designer.cs
    
    Matched files: Form1.cs;Form1.Designer.cs;Properties\Settings.Designer.cs
    

    Esse código define uma tarefa embutida chamada RegX e tem estes três parâmetros:

  • Expression é um parâmetro de entrada de cadeia de caracteres obrigatório que tem um valor que é a expressão regular com a qual a correspondência deve ser realizada. Neste exemplo, a expressão corresponde às palavras "public" ou "protected".

  • Files é um parâmetro de entrada de lista de item obrigatório que tem um valor que é uma lista de arquivos a serem pesquisados em busca da correspondência. Neste exemplo, Files é definido como o item Compile, que lista os arquivos de origem do projeto.

  • Result é um parâmetro de saída que tem um valor que é a lista de arquivos com o conteúdo que corresponde à expressão regular.

    Os valores dos parâmetros de entrada são definidos quando o destino TestBuild invoca a tarefa RegX. A tarefa RegX lê todos os arquivos e retorna a lista de arquivos que correspondem à expressão regular. Essa lista é retornada como o parâmetro de saída Result, que é emitido como o item MatchedFiles do MSBuild.

Gerenciar caracteres reservados

O analisador de MSBuild processa tarefas embutidas como XML. Caracteres que têm significado reservado em XML, por exemplo, "<" e ">", são detectados e manipulados como se fossem XML e não código-fonte .NET. Para incluir os caracteres reservados em expressões de código como Files.Length > 0, escreva o elemento Code para que seu conteúdo fique contido em uma expressão CDATA, da seguinte maneira:

<Code Type="Fragment" Language="cs">
 <![CDATA[

 if (Files.Length > 0)
 {
     // Your code goes here.
 }
 ]]>
</Code>