Utilisation du CodeDOMUsing the CodeDOM

CodeDOM fournit des types qui représentent de nombreux types courants d’éléments du code source.The CodeDOM provides types that represent many common types of source code elements. 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.You can design a program that builds a source code model using CodeDOM elements to assemble an object graph. 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.This object graph can be rendered as source code using a CodeDOM code generator for a supported programming language. CodeDOM permet également de compiler du code source dans un assembly binaire.The CodeDOM can also be used to compile source code into a binary assembly.

Voici quelques usages courants de CodeDOM :Some common uses for the CodeDOM include:

  • 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.Templated code generation: generating code for ASP.NET, XML Web services client proxies, code wizards, designers, or other code-emitting mechanisms.

  • Compilation dynamique : prise en charge de la compilation du code dans un ou plusieurs langages.Dynamic compilation: supporting code compilation in single or multiple languages.

Génération d’un graphique CodeDOMBuilding a CodeDOM Graph

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.The System.CodeDom namespace provides classes for representing the logical structure of source code, independent of language syntax.

Structure d’un graphique CodeDOMThe Structure of a CodeDOM Graph

La structure d’un graphique CodeDOM est comparable à une arborescence de conteneurs.The structure of a CodeDOM graph is like a tree of containers. Le conteneur de niveau supérieur, ou conteneur racine, de chaque graphique CodeDOM compilable est un CodeCompileUnit.The top-most, or root, container of each compilable CodeDOM graph is a 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.Every element of your source code model must be linked into the graph through a property of a CodeObject in the graph.

Génération d’un modèle de code source pour un exemple de programme Hello WorldBuilding a Source Code Model for a Sample Hello World Program

L’exemple ci-dessous montre comment générer un graphique d’objet CodeDOM représentant le code d’une application simple Hello World.The following walkthrough provides an example of how to build a CodeDOM object graph that represents the code for a simple Hello World application. Pour obtenir le code source complet pour cet exemple, consultez la rubrique System.CodeDom.Compiler.CodeDomProvider.For the complete source code for this code example, see the System.CodeDom.Compiler.CodeDomProvider topic.

Création d’une unité de compilationCreating a compile unit

CodeDOM définit un objet appelé CodeCompileUnit qui peut référencer un graphique d’objet CodeDOM modélisant le code source à compiler.The CodeDOM defines an object called a CodeCompileUnit, which can reference a CodeDOM object graph that models the source code to compile. CodeCompileUnit a des propriétés pour le stockage des références aux attributs, espaces de noms et assemblys.A CodeCompileUnit has properties for storing references to attributes, namespaces, and assemblies.

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.The CodeDom providers that derive from the CodeDomProvider class contain methods that process the object graph referenced by a 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.To create an object graph for a simple application, you must assemble the source code model and reference it from a CodeCompileUnit.

Vous pouvez créer une unité de compilation avec la syntaxe illustrée dans l’exemple suivant :You can create a new compile unit with the syntax demonstrated in this example:

CodeCompileUnit^ compileUnit = gcnew CodeCompileUnit();
CodeCompileUnit compileUnit = new CodeCompileUnit();
Dim compileUnit As New 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.A CodeSnippetCompileUnit can contain a section of source code that is already in the target language, but cannot be rendered to another language.

Définition d’un espace de nomsDefining a namespace

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.To define a namespace, create a CodeNamespace and assign a name for it using the appropriate constructor or by setting its Name property.

CodeNamespace^ samples = gcnew CodeNamespace("Samples");
CodeNamespace samples = new CodeNamespace("Samples");
Dim samples As New CodeNamespace("Samples")

Importation d’un espace de nomsImporting a namespace

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.To add a namespace import directive to the namespace, add a CodeNamespaceImport that indicates the namespace to import to the CodeNamespace.Imports collection.

Le code suivant ajoute une importation de l’espace de noms System à la collection Imports d’un CodeNamespace appelé samples :The following code adds an import for the System namespace to the Imports collection of a CodeNamespace named samples:

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

Liaison d’éléments de code à l’intérieur du graphique d’objetLinking code elements into the object graph

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.All code elements that form a CodeDOM graph must be linked to the CodeCompileUnit that is the root element of the tree by a series of references between elements directly referenced from the properties of the root object of the graph. Affectez un objet à une propriété d’un objet conteneur pour établir une référence à partir de cet objet.Set an object to a property of a container object to establish a reference from the container object.

L’instruction suivante ajoute le CodeNamespace samples à la propriété de collection Namespaces du CodeCompileUnit racine.The following statement adds the samples CodeNamespace to the Namespaces collection property of the root CodeCompileUnit.

compileUnit->Namespaces->Add( samples );
compileUnit.Namespaces.Add( samples );
compileUnit.Namespaces.Add(samples)

Définition d’un typeDefining a 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.To declare a class, structure, interface, or enumeration using the CodeDOM, create a new CodeTypeDeclaration, and assign it a name. L’exemple suivant illustre cette opération à l’aide d’une surcharge de constructeur définissant la propriété Name :The following example demonstrates this using a constructor overload to set the Name property:

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.To add a type to a namespace, add a CodeTypeDeclaration that represents the type to add to the namespace to the Types collection of a CodeNamespace.

L’exemple suivant montre comment ajouter une classe nommée class1 à un CodeNamespace nommé samples :The following example demonstrates how to add a class named class1 to a CodeNamespace named samples:

samples->Types->Add(class1);
samples.Types.Add(class1);
samples.Types.Add(class1)

Ajout de membres de classe à une classeAdding class members to a class

L’espace de noms System.CodeDom propose divers éléments que vous pouvez utiliser pour représenter des membres de classe.The System.CodeDom namespace provides a variety of elements that can be used to represent class members. Chaque membre de classe peut être ajouté à la collection Members d’un CodeTypeDeclaration.Each class member can be added to the Members collection of a CodeTypeDeclaration.

Définition d’une méthode de point d’entrée de code pour un exécutableDefining a code entry point method for an executable

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.If you are building code for an executable program, it is necessary to indicate the entry point of a program by creating a CodeEntryPointMethod to represent the method at which program execution should begin.

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! » :The following example demonstrates how to define an entry point method that contains a CodeMethodInvokeExpression that calls System.Console.WriteLine to print "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 :The following statement adds the entry point method named Start to the Members collection of 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.Now the CodeCompileUnit named compileUnit contains the CodeDOM graph for a simple Hello World program. 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.For information on generating and compiling code from a CodeDOM graph, see Generating Source Code and Compiling a Program from a CodeDOM Graph.

Complément d’information sur la génération d’un graphique CodeDOMMore information on building a CodeDOM graph

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.The CodeDOM supports the many common types of code elements found in programming languages that support the 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.The CodeDOM was not designed to provide elements to represent all possible programming language features. 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.Code that cannot be represented easily with CodeDOM elements can be encapsulated in a CodeSnippetExpression, a CodeSnippetStatement, a CodeSnippetTypeMember, or a CodeSnippetCompileUnit. Toutefois, certains extraits de code ne peuvent pas être traduits automatiquement dans d’autres langages par CodeDOM.However, snippets cannot be translated to other languages automatically by the CodeDOM.

Pour plus d’informations sur chacun des types CodeDOM, consultez la documentation de référence pour l’espace de noms System.CodeDom.For documentation for the each of the CodeDOM types, see the reference documentation for the System.CodeDom namespace.

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.For a quick chart to locate the CodeDOM element that represents a specific type of code element, see the CodeDOM Quick Reference.