Partager via

Procédure pas à pas : création d'une tâche inline

  • Article

En général, les tâches MSBuild sont créées en compilant une classe qui implémente l'interface ITask. À partir du .NET Framework version 4, vous pouvez créer des tâches inline dans le fichier projet. Vous n'avez pas besoin de créer un assembly séparé pour héberger la tâche. Pour plus d'informations, consultez Tâches inline MSBuild.

Cette procédure pas à pas indique comment créer et exécuter ces tâches inline :

  • Tâche qui n'a pas de paramètres d'entrée ou de sortie.

  • Tâche qui a un paramètre d'entrée et aucun paramètre de sortie.

  • Tâche avec deux paramètres d'entrée et un paramètre de sortie qui retourne une propriété MSBuild.

  • Tâche avec deux paramètres d'entrée et un paramètre de sortie qui retourne un élément MSBuild.

Pour créer et exécuter les tâches, utilisez Visual Studio et la fenêtre Invite de commandes de Visual Studio, comme suit :

  • Créez un fichier projet MSBuild à l'aide de Visual Studio.

  • Modifiez le fichier projet dans Visual Studio pour créer la tâche inline.

  • Utilisez la fenêtre Invite de commandes pour générer le projet et examiner les résultats.

Création et modification d'un projet MSBuild

Le système de projet Visual Studio est basé sur MSBuild. Par conséquent, vous pouvez créer un fichier projet de build à l'aide de Visual Studio. Dans cette section, vous créez un fichier projet Visual C#. (Vous pouvez créer à la place un fichier projet Visual Basic. Dans le contexte de ce didacticiel, la différence entre les deux fichiers projet est mineure.)

Pour créer et modifier un fichier projet

  1. Dans le menu Fichier de Visual Studio, cliquez sur Nouveau, puis sur Projet.

  2. Dans la boîte de dialogue Nouveau projet, sélectionnez le type de projet Visual C#, puis sélectionnez le modèle Application Windows Forms. Dans la zone Nom, tapez InlineTasks. Tapez un Emplacement pour la solution, par exemple, D:\. Assurez-vous que l'option Créer le répertoire pour la solution est sélectionnée, que l'option Ajouter au contrôle de code source ne l'est pas et que Nom de solution correspond à InlineTasks.

    Cliquez sur OK pour créer le fichier projet.

  3. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le nœud de projet InlineTasks, puis sur Décharger le projet.

  4. Cliquez avec le bouton droit sur le nœud du projet une nouvelle fois, puis cliquez sur Modifier InlineTasks.csproj.

    Le fichier projet apparaît dans l'éditeur de code.

Ajout d'une tâche Hello de base

À présent, ajoutez au fichier projet une tâche de base qui affiche le message "Hello, world!". Ajoutez également une cible TestBuild par défaut pour appeler la tâche.

Pour ajouter une tâche Hello de base

  1. Dans le nœud Project racine, remplacez l'attribut DefaultTargets par TestBuild. Le nœud Project résultant doit ressembler à cet exemple :

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

  2. Ajoutez la cible et la tâche inline suivantes au fichier projet juste avant la balise </Project>.

    <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. Enregistrez le fichier projet.

Ce code crée une tâche inline nommée Hello et n'a pas de paramètres, de références ou d'instructions Using. La tâche Hello contient une seule ligne de code, qui affiche un message de type Hello sur le périphérique de journalisation par défaut, généralement la fenêtre de console.

Exécution de la tâche Hello

Exécutez MSBuild à l'aide de la fenêtre d'invite de commandes pour construire la tâche Hello et traiter la cible TestBuild qui l'appelle.

Pour exécuter la tâche Hello

  1. Dans le menu Démarrer, cliquez sur Tous les programmes, puis recherchez le dossier Visual Studio Tools et cliquez sur Invite de commandes de Visual Studio.

  2. Dans la fenêtre d'invite de commandes, recherchez le dossier qui contient le fichier projet, dans le cas présent, D:\InlineTasks\InlineTasks\.

  3. Tapez msbuild sans commutateurs de commande, puis appuyez sur ENTRÉE. Par défaut, cela génère le fichier InlineTasks.csproj et traite la cible par défaut TestBuild, qui appelle la tâche Hello.

  4. Examinez la sortie dans la Fenêtre d'invite de commandes. Vous devriez voir cette ligne :

    Hello, world!

    Notes

    Si vous ne voyez pas le message de type Hello, essayez d'enregistrer à nouveau le fichier projet, puis exécutez la tâche Hello.

En alternant entre l'éditeur de code et la fenêtre d'invite de commandes, vous pouvez modifier le fichier projet et consulter rapidement les résultats.

Définition de la tâche Echo

Créez une tâche inline qui accepte un paramètre de chaîne et affiche la chaîne sur le périphérique de journalisation par défaut.

Pour définir la tâche Echo

  1. Dans l'éditeur de code, remplacez la tâche Hello et la cible TestBuild à l'aide du code suivant.

    <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. Dans la Fenêtre d'invite de commandes, tapez msbuild sans commutateurs de commande, puis appuyez sur Entrée. Par défaut, cela traite la cible par défaut TestBuild, qui appelle la tâche Echo.

  3. Examinez la sortie dans la Fenêtre d'invite de commandes. Vous devriez voir cette ligne :

    Greetings!

Ce code définit une tâche inline nommée Echo, qui a un seul paramètre d'entrée Text obligatoire. Par défaut, les paramètres sont de type System.String. La valeur du paramètre Text est définie lorsque la cible TestBuild appelle la tâche Echo.

Définition de la tâche Adder

Créez une tâche inline qui ajoute deux paramètres entiers et émet leur somme comme une propriété MSBuild.

Pour définir la tâche Adder

  1. Dans l'éditeur de code, remplacez la tâche Echo et la cible TestBuild à l'aide du code suivant.

    <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. Dans la Fenêtre d'invite de commandes, tapez msbuild sans commutateurs de commande, puis appuyez sur Entrée. Par défaut, cela traite la cible par défaut TestBuild, qui appelle la tâche Echo.

  3. Examinez la sortie dans la Fenêtre d'invite de commandes. Vous devriez voir cette ligne :

    The sum is 9

Ce code définit une tâche inline nommée Adder qui a deux paramètres d'entrée de type entier obligatoires, A et B, et un paramètre de sortie entier, C. La tâche Adder additionne les deux paramètres d'entrée et retourne la somme dans le paramètre de sortie. La somme est émise comme propriété MSBuild Sum. Les valeurs des paramètres d'entrée sont définies lorsque la cible TestBuild appelle la tâche Adder.

Définition de la tâche RegX

Créez une tâche inline qui accepte un groupe d'éléments et une expression régulière, et retourne la liste de tous les éléments dont le contenu du fichier correspond à l'expression.

Pour définir la tâche RegX

  1. Dans l'éditeur de code, remplacez la tâche Adder et la cible TestBuild à l'aide du code suivant.

    <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. Dans la Fenêtre d'invite de commandes, tapez msbuild sans commutateurs de commande, puis appuyez sur Entrée. Par défaut, cela traite la cible par défaut TestBuild, qui appelle la tâche RegX.

  3. Examinez la sortie dans la Fenêtre d'invite de commandes. Vous devriez voir ces lignes :

    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

Ce code définit une tâche inline nommée RegX qui a les trois paramètres suivants :

  • Expression est un paramètre d'entrée de chaîne obligatoire dont la valeur est l'expression régulière à mettre en correspondance. Dans cet exemple, l'expression correspond au mot « public » ou « protégé ».

  • Files est un paramètre d'entrée de liste d'éléments obligatoire dont la valeur est une liste de fichiers dans laquelle rechercher la correspondance. Dans cet exemple, Files a pour valeur l'élément Compile, qui répertorie les fichiers sources du projet.

  • Result est un paramètre de sortie qui a pour valeur la liste des fichiers dont le contenu correspond à l'expression régulière.

Les valeurs des paramètres d'entrée sont définies lorsque la cible TestBuild appelle la tâche RegX. La tâche RegX lit chaque fichier et retourne la liste des fichiers qui correspondent à l'expression régulière. Cette liste est retournée comme le paramètre de sortie Result, émis en tant qu'élément MSBuild MatchedFiles.

Gestion des caractères réservés

L'analyseur MSBuild traite les tâches inline au format XML. Les caractères qui ont une signification réservée au format XML, par exemple « < » et « > », sont détectés et gérés comme s'il s'agissait du format XML, et non de code source .NET. Pour inclure les caractères réservés dans les expressions de code telles que Files.Length > 0, écrivez l'élément Code afin que son contenu apparaisse dans une expression CDATA, comme suit :

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

<![CDATA[

// Your code goes here.

]]>

</Code>

Voir aussi

Concepts

Tâches inline MSBuild

Tâches MSBuild

Cibles de MSBuild