mardi 25 juin 2013

Moteur de Build Microsoft : MSBuild Engine (1)

MSBuild, est un outil de génération d'applications. Il utilise un schéma XML pour contrôler la génération de produits logiciels. Visual Studio utilise MSBuild mais MSBuild ne dépend pas de Visual Studio.

En appelant MSBuild sur un fichier projet ou solution, vous pouvez orchestrer ou générer des produits dans des environnements où Visual Studio n'est pas installé.

Dans les fichiers projets (.csproj) vous trouverez le code XML MSBuild qui s'exécute lorsque l'on génère l'application.

Ainsi vous pouvez modifier le système de génération et :
  • Prétraitez les fichiers avant qu'ils atteignent le compilateur.
  • Copiez les sorties de génération vers un autre emplacement.
  • Créez les fichiers compressés les sorties de génération.
  • Effectuez une étape de post-traitement. Par exemple, vous pouvez emboutir un assembly avec une version différente.
Exemple d'utilisation : Utiliser Visual Studio sur un ordinateur de développement pour écrire le code XML de MSBuild  à l'aide de l'IDE, puis transmettre ce code aux autres développeurs qui l'exécuteront en ligne de commande afin d'intégrer votre développement.

MSBuild est utilisé dans le cadre d'une stratégie d'intégration continue.

On trouve MSBuild.exe dans les répertoires :
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727
C:\WINDOWS\Microsoft.NET\Framework\v3.5

Egalement avec l'installation du Framework 4.5

Allez plus loin Ici.

Procédure pas à pas d'utilisation de MSBuild

Création d'un projet MSBuild et examen du fichier projet

Vous créez un projet avec Visual Studio, en suite pour éditer le fichier .csproj vous devez "Décharger  le projet" puis en cliquant bouton droit vous pourrez éditer, modifier le fichier .csproj.

Les fichiers XML MSBuild ont un noeud racine : "Project"
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build"  xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

Notion de Tâche MSBuild

Une tâche est la plus petite unité de travaille (l'atome) d'une build.

Les tâches MSBuild fournissent du code exécuter pendant le processus de génération. Chaque tâche est implémentée dans une classe .NET qui dérive de l'interface ITask.

Une bibliothèque de tâches courantes est fournit avec MSBuild mais pour écrire vos propre tâche il y a deux approches :
  • Implémentez l'interface ITask directement.
  • Dérivez votre classe de la classe d'assistance, Task, qui est définie dans l'assembly Microsoft.Build.Utilities.dll. La tâche implémente ITask et fournit des implémentations par défaut de quelques membres ITask. En outre, la journalisation est plus facile.
Exemple code C# :

using System;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;

namespace MyTasks
{
    public class SimpleTask : Task
    {
        public override bool Execute()
        {
            return true;
        }
    }
}

Le fichier projet qui exécute cette tâche :

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    <Target Name="MyTarget">
        <SimpleTask />
    </Target>
</Project>

Allez plus loin Ici

Pour exécuter une tâche, MSBuild a besoin de mapper la tâche sur l'assembly qui contient son implémentation à l'aide de UsingTask.

<UsingTask TaskName="TaskName"
    AssemblyName = "AssemblyName" 
    TaskFactory = "ClassName"
    Condition="'String A'=='String B'" />

Notion de Cible MSBuild

Une cible est une séquence nommée de tâches.

Déclaration des cibles dans le fichier projet

<Target Name="Construct">
    <Csc Sources="@(Compile)" />
</Target>

Cibles prédéfinies :

<Target Name="AfterBuild" >
   <Message Text="First occurrence" />
</Target>
<Target Name="AfterBuild" >
   <Message Text="Second occurrence" /> 
</Target>


Dans ce cas uniquement la "Second Occurence" sera exécutée car MSBuild n'exécute qu'une fois une cible unique.

Ordre de génération des cibles

  • Cibles initiales
  • Cibles par défaut
  • Première cible
  • Dépendances cible
  • BeforeTargets et AfterTargets (MSBuild 4.0)
Allez plus loin Ici.

Traitement par lots des cibles

Une cible peut avoir un attribut Outputs qui spécifie des métadonnées, dans ce cas, MSBuild exécute la cible une fois pour chaque valeur de métadonnées unique, en regroupant ou en "traitant par lot".
Exemple :

<ItemGroup>
    <Reference Include="System.Core">
      <RequiredTargetFramework>3.5</RequiredTargetFramework>
    </Reference>
    <Reference Include="System.Xml.Linq">
      <RequiredTargetFramework>3.5</RequiredTargetFramework>
    </Reference>
    <Reference Include="Microsoft.CSharp">
      <RequiredTargetFramework>4.0</RequiredTargetFramework>
    </Reference>
</ItemGroup>
<Target Name="AfterBuild"
    Outputs="%(Reference.RequiredTargetFramework)">
    <Message Text="Reference:
      @(Reference->'%(RequiredTargetFramework)')" />
</Target>

Donne à l'exécution :

   Reference: 3.5;3.5
   Reference: 4.0

Builds incrémentielles

Pour améliorer la vitesse de génération MSBuild utilise un mécanisme de build incrémentielle pour n'exécuter que les mises à jour. Un élément est considéré comme à jour si son fichier de sortie a la même ancienneté ou est plus ancien que son ou ses fichier(s) d'entrée.

Allez plus loin Ici.

Génération de la cible

On exécute MSBuild dans l'invite de commande de Visual Studio :

Dans le fichier myProject.csproj :

<Target Name="HelloWorld">
  <Message Text="Hello"></Message>
  <Message Text="World"></Message>
</Target>

En ligne de commande :

>msbuild myProject.csproj /t:HelloWorld

L'exécution avec le commutateur /t trouve la cible HelloWord et l'exéctute en sortie dans la fenêtre de commande on obtient :
Hello
World

Allez plus loin Ici.

MSBuild autres caractéristiques

Création de Tâches Inline Ici.

Quelques limitations de MSBuild

optimisé et facile d'utilisation qu'en association avec Visual Studio.
manuellement pénible et long d'écriture fichier dû au temps d'apprentissage de la syntaxe ...
les paramètres sont tous globaux.
plusieurs possibilités de référencer un item ou la valeur d'une propriété
la qualité de la documentation (semble s'être améliorée ...)

On parle de Ant ou NAnt également de GNU Make.

Nouveauté de la version MSBuild 4.5

Vous pouvez spécifier qu'une tâche s'exécute "out-of process" pour cibler un autre framework.net.
Vous pouvez générer des binaires qui ciblent un processeur ARM.
L'attribut d' ToolsVersion pour déterminer la version de l'ensemble d'outils MSBuild.

Nouveaux éléments du langage :
VisualStudioVersion
DoesTaskHostExist
Item
   KeepMetadata
   RemoveMetadata
   KeepDuplicates
ContinueOnError
   <Delete Files="@(Files)" ContinueOnError="WarnAndContinue"/>
   WarnAndContinue
   ErrorAndContinue
   ErrorAndStop

Aucun commentaire:

Publier un commentaire