Procédure pas à pas : génération de code à l'aide de modèles de texteWalkthrough: Generating Code by using Text Templates

La génération de code vous permet de générer du code de programme qui est fortement typé mais peut être facilement modifié quand le modèle source change.Code generation allows you to produce program code that is strongly typed, and yet can be easily changed when the source model changes. Comparez ceci avec l’autre technique consistant à écrire un programme complètement générique qui accepte un fichier de configuration, qui est plus flexible mais génère du code qui n’est pas aussi facile à lire et à modifier et n’offre pas d’aussi bonnes performances.Contrast this with the alternative technique of writing a completely generic program that accepts a configuration file, which is more flexible, but results in code that is neither so easy to read and change, nor has such good performance. Cette procédure pas à pas montre les avantages offerts par la génération de code.This walkthrough demonstrates this benefit.

Code typé pour lire des données XMLTyped code for reading XML

L’espace de noms System.Xml fournit des outils complets pour charger un document XML puis y accéder librement en mémoire.The System.Xml namespace provides comprehensive tools for loading an XML document and then navigating it freely in memory. Malheureusement, tous les nœuds ont le même type, XmlNode.Unfortunately, all the nodes have the same type, XmlNode. Ainsi, il est très facile de commettre des erreurs de programmation, par exemple attendre le type de nœud enfant incorrect ou les attributs incorrects.It is therefore very easy to make programming mistakes such as expecting the wrong type of child node, or the wrong attributes.

Dans cet exemple de projet, un modèle lit un exemple de fichier XML et génère des classes qui correspondent à chaque type de nœud.In this example project, a template reads a sample XML file, and generates classes that correspond to each type of node. Dans le code écrit manuellement, vous pouvez utiliser ces classes pour parcourir le fichier XML.In the hand-written code, you can use these classes to navigate the XML file. Vous pouvez également exécuter votre application sur tout autre fichier qui utilise les mêmes types de nœuds.You can also run your application on any other files that use the same node types. L’objectif de l’exemple de fichier XML est de fournir des exemples de tous les types de nœuds que vous souhaitez que votre application puisse gérer.The purpose of the sample XML file is to provide examples of all the node types that you want your application to deal with.

Note

L’application xsd.exe, qui est fournie avec Visual StudioVisual Studio, peut générer des classes fortement typées à partir de fichiers XML.The application xsd.exe, which is included with Visual StudioVisual Studio, can generate strongly-typed classes from XML files. Le modèle présenté ici est fourni comme exemple.The template shown here is provided as an example.

Voici l’exemple de fichier :Here is the sample file:

<?xml version="1.0" encoding="utf-8" ?>  
<catalog>  
  <artist id ="Mike%20Nash" name="Mike Nash Quartet">  
    <song id ="MikeNashJazzBeforeTeatime">Jazz Before Teatime</song>  
    <song id ="MikeNashJazzAfterBreakfast">Jazz After Breakfast</song>  
  </artist>  
  <artist id ="Euan%20Garden" name="Euan Garden">  
    <song id ="GardenScottishCountry">Scottish Country Garden</song>  
  </artist>  
</catalog>  

Dans le projet construit par cette procédure pas à pas, vous pouvez écrire du code semblable au suivant et IntelliSense vous présente les noms corrects des enfants et des attributs à mesure que vous tapez :In the project that this walkthrough constructs, you can write code such as the following, and IntelliSense prompts you with the correct attribute and child names as you type:

Catalog catalog = new Catalog(xmlDocument);  
foreach (Artist artist in catalog.Artist)  
{  
  Console.WriteLine(artist.name);  
  foreach (Song song in artist.Song)  
  {  
    Console.WriteLine("   " + song.Text);  
  }  
}  

Comparez cela avec le code non typé que vous pouvez écrire sans le modèle :Contrast this with the untyped code that you might write without the template:

XmlNode catalog = xmlDocument.SelectSingleNode("catalog");  
foreach (XmlNode artist in catalog.SelectNodes("artist"))  
{  
    Console.WriteLine(artist.Attributes["name"].Value);  
    foreach (XmlNode song in artist.SelectNodes("song"))  
    {  
         Console.WriteLine("   " + song.InnerText);  
     }  
}  

Dans la version fortement typée, une modification du schéma XML provoquera des modifications des classes.In the strongly typed version, a change to the XML schema will result in changes to the classes. Le compilateur mettra en évidence les parties du code d’application qui doivent être modifiées.The compiler will highlight the parts of the application code that must be changed. Dans la version non typée qui utilise du code XML générique, cette prise en charge n’existe pas.In the untyped version that uses generic XML code, there is no such support.

Dans ce projet, un seul fichier de modèle est utilisé pour générer les classes qui rendent la version typée possible.In this project, a single template file is used to generate the classes that make the typed version possible.

Configuration du projetSetting up the Project

Créer ou ouvrir un projet C#Create or open a C# project

Vous pouvez appliquer cette technique à tout projet de code.You can apply this technique to any code project. Cette procédure pas à pas utilise un projet C#, et à des fins de test nous utilisons une application console.This walkthrough uses a C# project, and for the purposes of testing we use a console application.

Pour créer le projetTo create the project
  1. Dans le menu Fichier , cliquez sur Nouveau , puis sur Projet.On the File menu click New and then click Project.

  2. Cliquez sur le nœud Visual C# puis, dans le volet Modèles , cliquez sur Application console.Click the Visual C# node, and then in the Templates pane, click Console Application.

Ajouter un fichier XML de prototype au projetAdd a prototype XML file to the project

L’objectif de ce fichier consiste à fournir des exemples des types de nœuds XML que vous souhaitez que votre application puisse lire.The purpose of this file is to provide samples of the XML node types that you want your application to be able to read. Il peut s’agir d’un fichier qui sera utilisé pour tester votre application.It could be a file that will be used for testing your application. Le modèle produira une classe C# pour chaque type de nœud dans ce fichier.The template will produce a C# class for each node type in this file.

Le fichier doit faire partie du projet pour que le modèle puisse le lire, mais il ne sera pas généré dans l’application compilée.The file should be part of the project so that the template can read it, but it will not be built into the compiled application.

Pour ajouter un fichier XMLTo add an XML file
  1. Dans l’ Explorateur de solutions, cliquez avec le bouton droit sur le projet, cliquez sur Ajouter , puis sur Nouvel élément.In Solution Explorer, right-click the project, click Add and then Click New Item.

  2. Dans la boîte de dialogue Ajouter un nouvel élément , sélectionnez Fichier XML dans le volet Modèles .In the Add New Item dialog box, select XML File from the Templates pane.

  3. Ajoutez votre exemple de contenu au fichier.Add your sample content to the file.

  4. Pour cette procédure pas à pas, nommez le fichier exampleXml.xml.For this walkthrough, name the file exampleXml.xml. Définissez le code XML fourni dans la section précédente comme contenu du fichier.Set the content of the file to be the XML shown in the previous section.

    ...

Ajouter un fichier de code de testAdd a test code file

Ajoutez un fichier C# à votre projet et placez-y un exemple du code que vous souhaitez pouvoir écrire.Add a C# file to your project and write in it a sample of the code that you want to be able to write. Par exemple :For example:

using System;  
namespace MyProject  
{  
  class CodeGeneratorTest  
  {  
    public void TestMethod()  
    {  
      Catalog catalog = new Catalog(@"..\..\exampleXml.xml");  
      foreach (Artist artist in catalog.Artist)  
      {  
        Console.WriteLine(artist.name);  
        foreach (Song song in artist.Song)  
        {  
          Console.WriteLine("   " + song.Text);  
} } } } }  

À ce stade, la compilation de ce code échouera.At this stage, this code will fail to compile. À mesure que vous écrivez le modèle, vous allez générer des classes qui permettent à la compilation de réussir.As you write the template, you will generate classes that allow it to succeed.

Un test plus complet pourrait vérifier le résultat de cette fonction de test par rapport au contenu connu de l’exemple de fichier XML.A more comprehensive test could check the output of this test function against the known content of the example XML file. Toutefois, dans cette procédure pas à pas nous nous satisferons de la réussite de la compilation de la méthode de test.But in this walkthrough, we will be satisfied when the test method compiles.

Ajouter un fichier de modèle de texteAdd a text template file

Ajoutez un fichier de modèle de texte et définissez « .cs » comme extension de sortie.Add a text template file, and set the output extension to ".cs".

Pour ajouter un fichier de modèle de texte à votre projetTo add a text template file to your project
  1. Dans l’ Explorateur de solutions, cliquez avec le bouton droit sur le projet, cliquez sur Ajouter, puis sur Nouvel élément.In Solution Explorer, right-click the project, click Add, and then click New Item.

  2. Dans la boîte de dialogue Ajouter un nouvel élément , sélectionnez Modèle de texte dans le volet Modèles .In the Add New Item dialog box select Text Template from the Templates pane.

    Note

    Vérifiez que vous ajoutez bien un Modèle de texte, et non un Modèle de texte prétraité.Make sure that you add a Text Template, and not a Preprocessed Text Template.

  3. Dans le fichier, dans la directive de modèle, affectez la valeur hostspecific à l’attribut true.In the file, in the template directive, change the hostspecific attribute to true.

    Cette modification permettra au code de modèle d’accéder aux services Visual StudioVisual Studio .This change will enable the template code to gain access to the Visual StudioVisual Studio services.

  4. Dans la directive de sortie, affectez « .cs » comme attribut d’extension, pour que le modèle génère un fichier C#.In the output directive, change the extension attribute to ".cs", so that the template generates a C# file. Dans un projet Visual Basic, vous choisiriez « .vb ».In a Visual Basic project, you would change it to ".vb".

  5. Enregistrez le fichier.Save the file. À ce stade, le fichier de modèle de texte doit contenir ces lignes :At this stage, the text template file should contain these lines:

    <#@ template debug="false" hostspecific="true" language="C#" #>  
    <#@ output extension=".cs" #>  
    

    ..

    Notez qu’un fichier .cs apparaît dans l’Explorateur de solutions comme fichier auxiliaire du fichier de modèle.Notice that a .cs file appears in Solution Explorer as a subsidiary of the template file. Vous pouvez le voir en cliquant sur [+] en regard du nom du fichier de modèle.You can see it by clicking [+] next to the name of the template file. Ce fichier est généré à partir du fichier de modèle chaque fois que vous enregistrez ou déplacez le focus hors du fichier de modèle.This file is generated from the template file whenever you save or move the focus away from the template file. Le fichier généré sera compilé dans le cadre de votre projet.The generated file will be compiled as part of your project.

    Pour plus de commodité pendant que vous développez le fichier de modèle, réorganisez les fenêtres du fichier de modèle et du fichier généré pour les visualiser les unes à côté des autres.For convenience while you develop the template file, arrange the windows of the template file and the generated file so that you can see them next to each other. Cela vous permet de voir immédiatement le résultat de votre modèle.This lets you see immediately the output of your template. Vous remarquerez également que quand votre modèle génère du code C# non valide, des erreurs sont affichées dans la fenêtre de message d’erreur.You will also notice that when your template generates invalid C# code, errors will appear in the error message window.

    Toute modification que vous effectuez directement dans le fichier généré sera perdue chaque fois que vous enregistrerez le fichier de modèle.Any edits you perform directly in the generated file will be lost whenever you save the template file. Vous devez donc éviter de modifier le fichier généré, ou le modifier uniquement pour de courts tests.You should therefore either avoid editing the generated file, or edit it only for short experiments. Il est parfois utile de tester un petit fragment de code dans le fichier généré, où IntelliSense fonctionne, puis de le copier dans le fichier de modèle.It is sometimes useful to try a short fragment of code in the generated file, where IntelliSense is in operation, and then copy it to the template file.

Développement du modèle de texteDeveloping the Text Template

En suivant les recommandations en matière de développement agile, nous allons développer le modèle par petites étapes, en supprimant certaines erreurs à chaque incrément, jusqu’à ce que le code de test se compile et s’exécute correctement.Following the best advice on agile development, we will develop the template in small steps, clearing some of the errors at each increment, until the test code compiles and runs correctly.

Prototyper le code à générerPrototype the code to be generated

Le code de test nécessite une classe pour chaque nœud dans le fichier.The test code requires a class for each node in the file. Ainsi, certaines des erreurs de compilation disparaîtront si vous ajoutez les lignes suivantes au modèle et que vous l’enregistrez ensuite :Therefore, some of the compilation errors will go away if you append these lines to the template, and then save it:

class Catalog {}   
class Artist {}  
class Song {}  

Cela vous aide à voir ce qui est nécessaire, mais les déclarations doivent être générées à partir des types de nœuds dans l’exemple de fichier XML.This helps you see what is required, but the declarations should be generated from the node types in the sample XML file. Supprimez ces lignes expérimentales du modèle.Delete these experimental lines from the template.

Générer du code d’application à partir du fichier XML de modèleGenerate application code from the model XML file

Pour lire le fichier XML et générer des déclarations de classe, remplacez le contenu du modèle par le code de modèle suivant :To read the XML file and generate class declarations, replace the template content with the following template code:

<#@ template debug="false" hostspecific="true" language="C#" #>  
<#@ output extension=".cs" #>  
<#@ assembly name="System.Xml"#>  
<#@ import namespace="System.Xml" #>  
<#  
 XmlDocument doc = new XmlDocument();  
 // Replace this file path with yours:  
 doc.Load(@"C:\MySolution\MyProject\exampleXml.xml");  
 foreach (XmlNode node in doc.SelectNodes("//*"))  
 {  
#>  
  public partial class <#= node.Name #> {}  
<#  
 }  
#>  

Remplacez le chemin de fichier par le chemin correct pour votre projet.Replace the file path with the correct path for your project.

Notez les délimiteurs de bloc de code <#...#>.Notice the code block delimiters <#...#>. Ces délimiteurs encadrent un fragment du code du programme qui génère le texte.These delimiters bracket a fragment of the program code that generates the text. Les délimiteurs de bloc d’expression <#=...#> encadrent une expression qui peut être évaluée comme chaîne.The expression block delimiters <#=...#> bracket an expression that can be evaluated to a string.

Quand vous écrivez un modèle qui génère du code source pour votre application, vous êtes confronté à deux textes de programme distincts.When you are writing a template that generates source code for your application, you are dealing with two separate program texts. Le programme contenu dans les délimiteurs de bloc de code s’exécute chaque fois que vous enregistrez le modèle ou que vous déplacez le focus vers une autre fenêtre.The program inside the code block delimiters runs every time that you save the template or move the focus to another window. Le texte qu’il génère, qui apparaît hors des délimiteurs, est copié dans le fichier généré et devient partie intégrante de votre code d’application.The text that it generates, which appears outside the delimiters, is copied to the generated file and becomes part of your application code.

La directive <#@assembly#> se comporte comme une référence, mettant l’assembly à disposition du code de modèle.The <#@assembly#> directive behaves like a reference, making the assembly available to the template code. La liste des assemblys visibles par le modèle est distincte de la liste de références dans le projet d’application.The list of assemblies seen by the template is separate from the list of References in the application project.

La directive <#@import#> agit comme une instruction using et vous permet d’utiliser les noms courts des classes dans l’espace de noms importé.The <#@import#> directive acts like a using statement, allowing you to use the short names of classes in the imported namespace.

Malheureusement, bien que ce modèle génère du code, il produit une déclaration de classe pour chaque nœud dans l’exemple de fichier XML. Ainsi, s’il existe plusieurs instances du nœud <song> , plusieurs déclarations de la classe song apparaissent.Unfortunately, although this template generates code, it produces a class declaration for every node in the example XML file, so that if there are several instances of the <song> node, several declarations of the class song will appear.

Lire le fichier de modèle, puis générer le codeRead the model file, then generate the code

De nombreux modèles de texte suivent un modèle dans lequel la première partie du modèle lit le fichier source et la deuxième génère le modèle.Many text templates follow a pattern in which the first part of the template reads the source file, and the second part generates the template. Nous devons lire l’intégralité de l’exemple de fichier pour récapituler les types de nœuds qu’il contient, puis générer les déclarations de classe.We need to read all of the example file to summarize the node types that it contains, and then generate the class declarations. Un autre <#@import#> est nécessaire pour que nous puissions utiliser Dictionary<>:.Another <#@import#> is needed so that we can use Dictionary<>:

<#@ template debug="false" hostspecific="true" language="C#" #>  
<#@ output extension=".cs" #>  
<#@ assembly name="System.Xml"#>  
<#@ import namespace="System.Xml" #>  
<#@ import namespace="System.Collections.Generic" #>  
<#  
 // Read the model file  
 XmlDocument doc = new XmlDocument();  
 doc.Load(@"C:\MySolution\MyProject\exampleXml.xml");  
 Dictionary <string, string> nodeTypes =   
        new Dictionary<string, string>();  
 foreach (XmlNode node in doc.SelectNodes("//*"))  
 {  
   nodeTypes[node.Name] = "";  
 }  
 // Generate the code  
 foreach (string nodeName in nodeTypes.Keys)  
 {  
#>  
  public partial class <#= nodeName #> {}  
<#  
 }  
#>  

Ajouter une méthode auxiliaireAdd an auxiliary method

Un bloc de contrôle de fonctionnalité de classe est un bloc dans lequel vous pouvez définir des méthodes auxiliaires.A class feature control block is a block in which you can define auxiliary methods. Le bloc est délimité par <#+...#> et il doit apparaître comme dernier bloc dans le fichier.The block is delimited by <#+...#> and it must appear as the last block in the file.

Si vous préférez que les noms de classes commencent par une lettre majuscule, vous pouvez remplacer la dernière partie du modèle par le code de modèle suivant :If you prefer class names to begin with an uppercase letter, you can replace the last part of the template with the following template code:

// Generate the code  
 foreach (string nodeName in nodeTypes.Keys)  
 {  
#>  
  public partial class <#= UpperInitial(nodeName) #> {}  
<#  
 }  
#>  
<#+  
 private string UpperInitial(string name)  
 { return name[0].ToString().ToUpperInvariant() + name.Substring(1); }  
#>  

À ce stade, le fichier .cs généré contient les déclarations suivantes :At this stage, the generated .cs file contains the following declarations:

public partial class Catalog {}  
public partial class Artist {}  
public partial class Song {}  

Vous pouvez ajouter plus de détails tels que les propriétés des nœuds enfants, des attributs et du texte interne à l’aide de la même approche.More details such as properties for the child nodes, attributes, and inner text can be added using the same approach.

Accès à l’API Visual StudioAccessing the Visual Studio API

La définition de l’attribut hostspecific de la directive <#@template#> permet au modèle d’accéder à l’API Visual StudioVisual Studio .Setting the hostspecific attribute of the <#@template#> directive allows the template to obtain access to the Visual StudioVisual Studio API. Le modèle peut utiliser cette API pour obtenir l’emplacement des fichiers projet, pour éviter d’utiliser un chemin absolu dans le code du modèle.The template can use this to obtain the location of the project files, to avoid using an absolute file path in the template code.

<#@ template debug="false" hostspecific="true" language="C#" #>  
...  
<#@ assembly name="EnvDTE" #>  
...  
EnvDTE.DTE dte = (EnvDTE.DTE) ((IServiceProvider) this.Host)  
                       .GetService(typeof(EnvDTE.DTE));  
// Open the prototype document.  
XmlDocument doc = new XmlDocument();  
doc.Load(System.IO.Path.Combine(dte.ActiveDocument.Path, "exampleXml.xml"));  

Achèvement du modèle de texteCompleting the Text Template

Le contenu de modèle suivant génère du code qui permet de compiler et d’exécuter le code de test.The following template content generates code that allows the test code to compile and run.

<#@ template debug="false" hostspecific="true" language="C#" #>  
<#@ output extension=".cs" #>  
<#@ assembly name="System.Xml" #>  
<#@ assembly name="EnvDTE" #>  
<#@ import namespace="System.Xml" #>  
<#@ import namespace="System.Collections.Generic" #>  
using System;using System.Collections.Generic;using System.Linq;using System.Xml;namespace MyProject{  
<#  
 // Map node name --> child name --> child node type  
 Dictionary<string, Dictionary<string, XmlNodeType>> nodeTypes = new Dictionary<string, Dictionary<string, XmlNodeType>>();  

 // The Visual Studio host, to get the local file path.  
 EnvDTE.DTE dte = (EnvDTE.DTE) ((IServiceProvider) this.Host)  
                       .GetService(typeof(EnvDTE.DTE));  
 // Open the prototype document.  
 XmlDocument doc = new XmlDocument();  
 doc.Load(System.IO.Path.Combine(dte.ActiveDocument.Path, "exampleXml.xml"));  
 // Inspect all the nodes in the document.  
 // The example might contain many nodes of the same type,   
 // so make a dictionary of node types and their children.  
 foreach (XmlNode node in doc.SelectNodes("//*"))  
 {  
   Dictionary<string, XmlNodeType> subs = null;  
   if (!nodeTypes.TryGetValue(node.Name, out subs))  
   {  
     subs = new Dictionary<string, XmlNodeType>();  
     nodeTypes.Add(node.Name, subs);  
   }  
   foreach (XmlNode child in node.ChildNodes)  
   {  
     subs[child.Name] = child.NodeType;  
   }   
   foreach (XmlNode child in node.Attributes)  
   {  
     subs[child.Name] = child.NodeType;  
   }  
 }  
 // Generate a class for each node type.  
 foreach (string className in nodeTypes.Keys)  
 {  
    // Capitalize the first character of the name.  
#>  
    partial class <#= UpperInitial(className) #>  
    {      private XmlNode thisNode;      public <#= UpperInitial(className) #>(XmlNode node)       { thisNode = node; }  

<#  
    // Generate a property for each child.  
    foreach (string childName in nodeTypes[className].Keys)  
    {  
      // Allow for different types of child.  
      switch (nodeTypes[className][childName])  
      {  
         // Child nodes:  
         case XmlNodeType.Element:  
#>  
      public IEnumerable<<#=UpperInitial(childName)#>><#=UpperInitial(childName) #>      {         get         {            foreach (XmlNode node in                thisNode.SelectNodes("<#=childName#>"))              yield return new <#=UpperInitial(childName)#>(node);       } }  
<#  
         break;  
         // Child attributes:  
         case XmlNodeType.Attribute:  
#>  
      public string <#=childName #>      { get { return thisNode.Attributes["<#=childName#>"].Value; } }  
<#  
         break;  
         // Plain text:  
         case XmlNodeType.Text:  
#>  
      public string Text  { get { return thisNode.InnerText; } }  
<#  
         break;  
       } // switch  
     } // foreach class child  
  // End of the generated class:  
#>  
   }   
<#  
 } // foreach class  

   // Add a constructor for the root class   
   // that accepts an XML filename.  
   string rootClassName = doc.SelectSingleNode("*").Name;  
#>  
   partial class <#= UpperInitial(rootClassName) #>   {      public <#= UpperInitial(rootClassName) #>(string fileName){        XmlDocument doc = new XmlDocument();        doc.Load(fileName);        thisNode = doc.SelectSingleNode("<#=rootClassName#>");}   }}  
<#+  
   private string UpperInitial(string name)  
   {  
      return name[0].ToString().ToUpperInvariant() + name.Substring(1);  
   }  
#>  

Exécution du programme de testRunning the test program

Dans la partie principale de l’application console, les lignes suivantes exécutent la méthode de test.In the main of the console application, the following lines will execute the test method. Appuyez sur F5 pour exécuter le programme en mode débogage :Press F5 to run the program in debug mode:

using System;  
namespace MyProject  
{ class Program  
  { static void Main(string[] args)  
    { new CodeGeneratorTest().TestMethod();  
      // Allow user to see the output:  
      Console.ReadLine();  
} } }  

Écriture et mise à jour de l’applicationWriting and updating the application

L’application peut désormais être écrite dans un style fortement typé, en utilisant les classes générées plutôt que du code XML générique.The application can now be written in strongly-typed style, using the generated classes instead of using generic XML code.

Quand le schéma XML change, de nouvelles classes peuvent facilement être générées.When the XML schema changes, new classes can easily be generated. Le compilateur indiquera au développeur l’endroit où le code d’application doit être mis à jour.The compiler will tell the developer where the application code must be updated.

Pour régénérer les classes quand l’exemple de fichier XML est modifié, cliquez sur Transformer tous les modèles dans la barre d’outils de l’Explorateur de solutions.To regenerate the classes when the example XML file is changed, click Transform All Templates in the Solution Explorer toolbar.

ConclusionConclusion

Cette procédure pas à pas illustre plusieurs techniques et avantages de la génération de code :This walkthrough demonstrates several techniques and benefits of code generation:

  • Lagénération de code est la création d’une partie du code source de votre application à partir d’un modèle.Code generation is the creation of part of the source code of your application from a model. Le modèle contient des informations dans un format adapté au domaine d’application, et il peut changer pendant la durée de vie de l’application.The model contains information in a form suited to the application domain, and may change over the lifetime of the application.

  • Le typage fort est l’un des avantages de la génération de code.Strong typing is one benefit of code generation. Tandis que le modèle représente les informations dans un format plus adapté à l’utilisateur, le code généré permet à d’autres parties de l’application de traiter les informations à l’aide d’un ensemble de types.While the model represents information in a form more suitable to the user, the generated code allows other parts of the application to deal with the information using a set of types.

  • IntelliSense et le compilateur vous aident à créer du code conforme au schéma du modèle, à la fois quand vous écrivez du nouveau code et quand le schéma est mis à jour.IntelliSense and the compiler help you create code that adheres to the schema of the model, both when you write new code and when the schema is updated.

  • Ces avantages peuvent être obtenus grâce à l’ajout d’un fichier de modèle simple et unique à un projet.The addition of a single uncomplicated template file to a project can provide these benefits.

  • Un modèle de texte peut être développé et testé rapidement et de façon incrémentielle.A text template can be developed and tested rapidly and incrementally.

    Dans cette procédure pas à pas, le code du programme est généré à partir d’une instance du modèle, un exemple représentatif des fichiers XML que l’application traitera.In this walkthrough, the program code is actually generated from an instance of the model, a representative example of the XML files that the application will process. Dans une approche plus formelle, le schéma XML serait l’entrée du modèle, sous la forme d’un fichier .xsd ou d’une définition de langage propre au domaine.In a more formal approach, the XML schema would be the input to the template, in the form of an .xsd file or a domain-specific language definition. Cette approche faciliterait pour le modèle la détermination de caractéristiques telles que la multiplicité d’une relation.That approach would make it easier for the template to determine characteristics such as the multiplicity of a relationship.

Résolution des problèmes liés au modèle de texteTroubleshooting the Text Template

Si vous avez vu des erreurs de compilation ou de transformation du modèle dans la Liste d’erreurs ou si le fichier de sortie n’a pas été généré correctement, vous pouvez résoudre les problèmes du modèle de texte avec les techniques décrites dans Génération de fichiers avec l’utilitaire TextTransform.If you have seen template transformation or compilation errors in the Error List, or if the output file was not generated correctly, you can troubleshoot the text template with the techniques described in Generating Files with the TextTransform Utility.

Voir aussiSee Also

Génération de code au moment du design à l’aide de modèles de texte T4 Design-Time Code Generation by using T4 Text Templates
Écriture d’un modèle de texte T4Writing a T4 Text Template