Utilisation du CodeDOM

Le CodeDOM fournit des types qui représentent beaucoup de 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'objets. Ce graphique d'objets 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. Le CodeDOM permet également de compiler du code source dans un assembly binaire.

Les usages courants du CodeDOM sont les suivants :

• 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ération d'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'objets CodeDOM représentant le code d'une application exemple Hello world. Pour obtenir le code source complet pour cet exemple, consultez la rubrique System.CodeDom.Compiler.CodeDomProvider.

Création d'une unité de compilation

Le CodeDOM définit un objet appelé CodeCompileUnit qui peut référencer un graphique d'objets CodeDOM modélisant le code source à compiler. CodeCompileUnit possède 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'objets référencé par CodeCompileUnit.

Pour créer un graphique d'objets 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 nouvelle unité de compilation avec la syntaxe illustrée dans l'exemple suivant :

Dim compileUnit As New CodeCompileUnit()

CodeCompileUnit compileUnit = new CodeCompileUnit();

CodeCompileUnit^ compileUnit = gcnew CodeCompileUnit();

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éfinition d'un espace de noms

Pour définir un espace de noms, créez un nouveau CodeNamespace et assignez-lui un nom à l'aide du constructeur approprié ou en définissant sa propriété Name.

Dim samples As New CodeNamespace("Samples")

CodeNamespace samples = new CodeNamespace("Samples");

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

Importation d'un espace de noms

Pour ajouter une directive d'importation d'espace de noms à l'espace de noms, ajoutez 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(new CodeNamespaceImport("System"))

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

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

Liaison d'éléments de code à l'intérieur du graphique d'objets

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. Assignez un objet à une propriété d'un objet conteneur pour établir une référence à partir de cet objet.

L'instruction suivante ajoute CodeNamespace samples à la propriété de collection Namespaces du CodeCompileUnit racine.

compileUnit.Namespaces.Add(samples)

compileUnit.Namespaces.Add( samples );

compileUnit->Namespaces->Add( samples );

Définition d'un type

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

Dim class1 As New CodeTypeDeclaration("Class1")

CodeTypeDeclaration class1 = new CodeTypeDeclaration("Class1");

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

Pour ajouter un type à un espace de noms, ajoutez un CodeTypeDeclaration représentant ce type à la collection Types de 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);

Ajout de membres de classe à une classe

L'espace de noms System.CodeDom fournit divers éléments qui permettent de représenter des membres de classe. Chaque membre de classe peut être ajouté à la collection Members de CodeTypeDeclaration.

Définition d'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 nouveau 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! » :

Dim start As New CodeEntryPointMethod()
Dim cs1 As New CodeMethodInvokeExpression( _
    New CodeTypeReferenceExpression("System.Console"), _
    "WriteLine", new 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);

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

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

class1.Members.Add( start)

class1.Members.Add( start );

class1->Members->Add(start);

À présent, l'objet CodeCompileUnit appelé CompileUnit contient le graphique CodeDOM d'un simple programme Hello World. Pour plus d'informations sur la génération et la compilation de code à partir d'un graphique CodeDOM, consultez Génération du 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

Le CodeDOM prend en charge les nombreux types communs d'éléments de code des langages de programmation prenant en charge le Common Language Runtime. Le CodeDOM n'a pas été conçu pour fournir des éléments pour représenter 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 CodeSnippetExpression, CodeSnippetStatement, CodeSnippetTypeMemberou CodeSnippetCompileUnit. Toutefois, certains extraits de code ne peuvent pas être traduits automatiquement dans d'autres langages par le CodeDOM.

Pour plus d'informations sur chacun des types CodeDOM, consultez la documentation de référence sur 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.