Compartilhar via

Instruções passo a passo: criando uma tarefa embutida

  • Artigo

Tarefas do MSBuild são geralmente criadas por meio da compilação de uma classe que implementa o ITask interface. Começando com o.NET Framework versão 4, você pode criar tarefas embutido no arquivo de projeto. Você não precisará criar um assembly separado para hospedar a tarefa. Para obter mais informações, consulte Tarefas embutidas do MSBuild.

Esta explicação passo a passo mostra como criar e executar essas tarefas in-line:

  • Uma tarefa que tem parâmetros de entrada ou saídos.

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

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

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

Para criar e executar as tarefas, use o Visual Studio e o Visual Studio janela de Prompt de comando de, da seguinte forma:

  • Crie um arquivo de projeto MSBuild, usando o Visual Studio.

  • Modificar o arquivo de projeto Visual Studio para criar a tarefa in-line.

  • Use o Janela Prompt de comando para construir o projeto e examinar os resultados.

Criar e modificar um projeto MSBuild

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

Para criar e modificar um arquivo de projeto

  1. No Visual Studio, no menu Arquivo, clique em Novo e então em Projeto.

  2. No Novo projeto caixa de diálogo, selecione Visual C# tipo de projeto e selecione o Windows Forms Application modelo. No nome , digite InlineTasks. Digite uma local para a solução, por exemplo, ., D:\. Certifique-se de que Create directory for solution estiver selecionada, Add to Source Control estiver desmarcada, e Nome da solução é InlineTasks.

    Clique em OK para criar o arquivo de projeto.

  3. Em Solution Explorer, clique com o botão direito no nó do projeto InlineTasks e, em seguida, clique em Unload Project.

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

    O arquivo de projeto aparece no editor de código.

Adicionando uma tarefa básica de saudação

Agora, adicione o arquivo de projeto uma tarefa básica que exibe a mensagem "Hello, world!" Também adicione um destino de TestBuild padrão para invocar a tarefa.

Para adicionar uma tarefa básica de saudação

  1. Na raiz do Project nó, alterar o DefaultTargets para o atributo TestBuild.O resultante Project nó deverá ser semelhante a este exemplo:

    <Project ToolsVersion="4.0" DefaultTargets="TestBuild" xmlns="https://schemas.microsoft.com/developer/msbuild/2003">

  2. Adicione a seguinte tarefa in-line e de destino para o arquivo de projeto antes de </Project> marca.

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

  3. Salve o arquivo de projeto.

Esse código cria uma tarefa in-line chamada Hello e não tem parâmetros, referências, ou Using instruções. A tarefa de saudação contém apenas uma linha de código, que exibe uma mensagem de saudação no dispositivo de log padrão, normalmente a janela do console.

Executando a tarefa de saudação

Executar MSBuild usando o Janela Prompt de comando para construir a tarefa de saudação e processar o destino de TestBuild que invoca a ele.

Para executar a tarefa de saudação

  1. Clique em Iniciar, clique em Todos os programase localize o Visual Studio Tools pasta e clique em Visual Studio Prompt de comando de.

  2. No Janela Prompt de comando, localize a pasta que contém o arquivo de projeto, nesse caso, D:\InlineTasks\InlineTasks\.

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

  4. Examine a saída na Janela Prompt de comando. Você verá esta linha:

    Hello, world!

    Dica

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

Alternando entre o editor de código e o Janela Prompt de comando, você pode alterar o arquivo de projeto e ver rapidamente os resultados.

Definindo a tarefa de eco

Crie uma tarefa de embutido que aceita um parâmetro de seqüência de caracteres e exibe a seqüência em que o dispositivo de log do padrão.

Para definir a tarefa de eco

  1. No editor de código, substitua a tarefa de saudação e o destino de 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(Text, MessageImportance.High);
    </Code>
  </Task>
</UsingTask>
<Target Name="TestBuild">
  <Echo Text="Greetings!" />
</Target>

  2. No Janela Prompt de comando, tipo msbuild sem opções de comando e pressione ENTER. Por padrão, isso processa o destino padrão TestBuild, que chama a tarefa de eco.

  3. Examine a saída na Janela Prompt de comando. Você verá esta linha:

    Greetings!

Esse código define uma tarefa de in-line que é nomeada o eco e tem apenas um parâmetro de entrada necessário texto. Por padrão, os parâmetros são do tipo System. String. O valor do parâmetro de texto é definido quando o destino TestBuild invoca a tarefa de eco.

A definição de tarefa somador

Crie uma tarefa de embutido que adiciona dois parâmetros de inteiro e emite seu soma como uma propriedade do MSBuild.

Para definir a tarefa somador

  1. No editor de código, substitua a tarefa de eco e a destino de 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. No Janela Prompt de comando, tipo msbuild sem opções de comando e pressione ENTER. Por padrão, isso processa o destino padrão TestBuild, que chama a tarefa de eco.

  3. Examine a saída na Janela Prompt de comando. Você verá esta linha:

    The sum is 9

Este código define uma tarefa de in-line chamado somador e dois exigiu parâmetros de entrada de número inteiro, A e B, e parâmetro, c. de saída de um inteiro A tarefa somador adiciona os dois parâmetros de entrada e retorna a soma o parâmetro de saída. A soma é emitida como a propriedade MSBuild Sum. Os valores dos parâmetros de entrada são definidos quando o destino TestBuild invoca a tarefa somador.

Definindo a tarefa de RegX

Crie uma tarefa de embutido que aceite um grupo de itens e uma expressão regular e retorna uma lista de todos os itens que possuem o conteúdo do arquivo que corresponde à expressão.

Para definir a tarefa de RegX

  1. No editor de código, substitua a tarefa somador e destino de 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. No Janela Prompt de comando, tipo msbuild sem opções de comando e pressione ENTER. Por padrão, isso processa o destino padrão TestBuild, que chama a tarefa de RegX.

  3. Examine a saída na Janela Prompt de comando. Você deve 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

Este código define uma tarefa de in-line chamada RegX e tem esses três parâmetros:

  • Expressioné um parâmetro de entrada de seqüência de caracteres necessários que possui um valor que é a expressão regular a ser correspondido. Neste exemplo, a expressão corresponde as palavras "públicas" ou "protegidas".

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

  • Resulté um parâmetro de saída que tem um valor que é a lista de arquivos que possuem conteúdo que corresponde a expressões regulares.

O valor dos parâmetros de entrada são definidos quando o destino TestBuild invoca a tarefa de RegX. A tarefa de RegX lê cada arquivo e retorna a lista de arquivos que correspondem a expressões regulares. Esta lista é retornada como a Result parâmetro de saída, que é emitido como o item MSBuild MatchedFiles.

Caracteres reservados de tratamento

O analisador do MSBuild processa in-line tarefas como XML. Caracteres reservado significado em XML, por exemplo, "<" e ">", são detectados e tratados 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, escrever o Code elemento para que seu conteúdo está contido em uma expressão CDATA, da seguinte maneira:

<Code Type="Fragment" Language="cs">

<![CDATA[

// Your code goes here.

]]>

</Code>

Consulte também

Conceitos

Tarefas embutidas do MSBuild

Tarefas do MSBuild

Destinos do MSBuild