Utiliser le CodeDOM

  • Article

CodeDOM fournit des types qui représentent de nombreux types courants d’éléments du code source. Vous pouvez concevoir un programme qui génère un modèle de code source à l’aide d’éléments CodeDOM pour assembler un graphique d’objet. Ce graphique d’objet peut être rendu sous forme de code source à l’aide d’un générateur de code CodeDOM pour un langage de programmation pris en charge. CodeDOM permet également de compiler du code source dans un assembly binaire.

Voici quelques usages courants de CodeDOM :

  • Génération d’un code modèle : génération du code pour ASP.NET, les proxies clients de services Web XML, les Assistants Code, les concepteurs ou d’autres mécanismes d’émission de code.
  • Compilation dynamique : prise en charge de la compilation du code dans un ou plusieurs langages.

Générer un graphique CodeDOM

L’espace de noms System.CodeDom fournit des classes représentant la structure logique du code source, indépendamment de la syntaxe d’un langage.

Structure d’un graphique CodeDOM

La structure d’un graphique CodeDOM est comparable à une arborescence de conteneurs. Le conteneur de niveau supérieur, ou conteneur racine, de chaque graphique CodeDOM compilable est un CodeCompileUnit. Chaque élément de votre modèle de code source doit être lié au graphique par le biais d’une propriété d’un CodeObject du graphique.

Génération d’un modèle de code source pour un exemple de programme Hello World

L’exemple ci-dessous montre comment générer un graphique d’objet CodeDOM représentant le code d’une application simple Hello World. Pour obtenir le code source complet pour cet exemple, consultez l’article System.CodeDom.Compiler.CodeDomProvider.

Création d’une unité de compilation

CodeDOM définit un objet appelé CodeCompileUnit qui peut référencer un graphique d’objet CodeDOM modélisant le code source à compiler. CodeCompileUnit a des propriétés pour le stockage des références aux attributs, espaces de noms et assemblys.

Les fournisseurs CodeDOM qui dérivent de la classe CodeDomProvider contiennent des méthodes qui traitent le graphique d’objet référencé par CodeCompileUnit.

Pour créer un graphique d’objet pour une application simple, vous devez assembler le modèle de code source et le référencer à partir de CodeCompileUnit.

Vous pouvez créer une unité de compilation avec la syntaxe illustrée dans l’exemple suivant :

CodeCompileUnit^ compileUnit = gcnew CodeCompileUnit();

CodeCompileUnit compileUnit = new CodeCompileUnit();

Dim compileUnit As New CodeCompileUnit()

Une classe CodeSnippetCompileUnit peut contenir une section de code source qui figure déjà dans le langage cible, mais ne peut pas être rendue dans un autre langage.

Définir un espace de noms

Pour définir un espace de noms, créez un CodeNamespace et nommez-le en utilisant le constructeur approprié ou en définissant sa propriété Name.

CodeNamespace^ samples = gcnew CodeNamespace("Samples");

CodeNamespace samples = new CodeNamespace("Samples");

Dim samples As New CodeNamespace("Samples")

Importer un espace de noms

Pour ajouter une directive d’importation d’espace de noms à l’espace de noms, ajoutez un CodeNamespaceImport qui spécifie l’espace de noms à importer dans la collection CodeNamespace.Imports.

Le code suivant ajoute une importation de l’espace de noms System à la collection Imports d’un CodeNamespace appelé samples :

samples->Imports->Add(gcnew CodeNamespaceImport("System"));

samples.Imports.Add(new CodeNamespaceImport("System"));

samples.Imports.Add(new CodeNamespaceImport("System"))

Tous les éléments de code qui forment un graphique CodeDOM doivent être liés au CodeCompileUnit qui constitue l’élément racine de l’arborescence par une série de références entre des éléments directement référencés à partir des propriétés de l’objet racine du graphique. Affectez un objet à une propriété d’un objet conteneur pour établir une référence à partir de cet objet.

L’instruction suivante ajoute le CodeNamespacesamples à la propriété de collection Namespaces du CodeCompileUnit racine.

compileUnit->Namespaces->Add( samples );

compileUnit.Namespaces.Add( samples );

compileUnit.Namespaces.Add(samples)

Définir un type

Pour déclarer une classe, une structure, une interface ou une énumération à l’aide de CodeDOM, créez un CodeTypeDeclaration et nommez-le. L’exemple suivant illustre cette opération à l’aide d’une surcharge de constructeur définissant la propriété Name :

CodeTypeDeclaration^ class1 = gcnew CodeTypeDeclaration("Class1");

CodeTypeDeclaration class1 = new CodeTypeDeclaration("Class1");

Dim class1 As New CodeTypeDeclaration("Class1")

Pour ajouter un type à un espace de noms, ajoutez un CodeTypeDeclaration représentant ce type à la collection Types d’un CodeNamespace.

L’exemple suivant montre comment ajouter une classe nommée class1 à un CodeNamespace nommé samples :

samples->Types->Add(class1);

samples.Types.Add(class1);

samples.Types.Add(class1)

Ajouter des membres à une classe

L’espace de noms System.CodeDom propose divers éléments que vous pouvez utiliser pour représenter des membres de classe. Chaque membre de classe peut être ajouté à la collection Members d’un CodeTypeDeclaration.

Définir une méthode de point d’entrée de code pour un exécutable

Si vous créez le code d’un programme exécutable, il est nécessaire d’indiquer le point d’entrée du programme en créant un CodeEntryPointMethod qui représente la méthode à laquelle doit commencer l’exécution du programme.

L’exemple suivant montre comment définir une méthode de point d’entrée qui contient un CodeMethodInvokeExpression qui appelle System.Console.WriteLine pour imprimer « Hello World! » :

CodeEntryPointMethod^ start = gcnew CodeEntryPointMethod();
CodeMethodInvokeExpression^ cs1 = gcnew CodeMethodInvokeExpression(
    gcnew CodeTypeReferenceExpression("System.Console"),
    "WriteLine", gcnew CodePrimitiveExpression("Hello World!"));
start->Statements->Add(cs1);

CodeEntryPointMethod start = new CodeEntryPointMethod();
CodeMethodInvokeExpression cs1 = new CodeMethodInvokeExpression(
    new CodeTypeReferenceExpression("System.Console"),
    "WriteLine", new CodePrimitiveExpression("Hello World!"));
start.Statements.Add(cs1);

Dim start As New CodeEntryPointMethod()
Dim cs1 As New CodeMethodInvokeExpression( _
    New CodeTypeReferenceExpression("System.Console"), _
    "WriteLine", new CodePrimitiveExpression("Hello World!"))
start.Statements.Add(cs1)

L’instruction suivante ajoute la méthode de point d’entrée nommée Start à la collection Members de class1 :

class1->Members->Add(start);

class1.Members.Add( start );

class1.Members.Add(start)

À présent, le CodeCompileUnit nommé compileUnit contient le graphique CodeDOM d’un programme Hello World simple. Pour plus d’informations sur la génération et la compilation de code à partir d’un graphique CodeDOM, consultez Génération de code source et compilation d’un programme à partir d’un graphique CodeDOM.

Complément d’information sur la génération d’un graphique CodeDOM

CodeDOM prend en charge les nombreux types communs d’éléments de code présents dans les langages de programmation compatibles avec le common language runtime. CodeDOM n’a pas été conçu pour fournir des éléments représentant toutes les fonctionnalités de langage de programmation possibles. Le code qui ne peut pas être facilement représenté à l’aide d’éléments CodeDOM peut être encapsulé dans un CodeSnippetExpression, un CodeSnippetStatement, un CodeSnippetTypeMember ou un CodeSnippetCompileUnit. Toutefois, certains extraits de code ne peuvent pas être traduits automatiquement dans d’autres langages par CodeDOM.

Pour plus d’informations sur chacun des types CodeDOM, consultez la documentation de référence pour l’espace de noms System.CodeDom.

Pour obtenir un graphique permettant de retrouver rapidement l’élément CodeDOM à utiliser pour représenter un type d’élément de code particulier, consultez Aide-mémoire de CodeDOM.