CodeCompiler Classe

Définition

Espace de noms:

System.CodeDom.Compiler

Assembly:

System.CodeDom.dll

Source:

CodeCompiler.cs

Fournit un exemple d’implémentation de l’interface ICodeCompiler .

public ref class CodeCompiler abstract : System::CodeDom::Compiler::CodeGenerator, System::CodeDom::Compiler::ICodeCompiler

public abstract class CodeCompiler : System.CodeDom.Compiler.CodeGenerator, System.CodeDom.Compiler.ICodeCompiler

type CodeCompiler = class
    inherit CodeGenerator
    interface ICodeCompiler

Public MustInherit Class CodeCompiler
Inherits CodeGenerator
Implements ICodeCompiler

Héritage

Object

CodeGenerator

CodeCompiler

Implémente

ICodeCompiler

Remarques

CodeCompiler est une classe de base utilitaire utile pour les générateurs de code à dériver afin de fournir des fonctions de compilation de code.

Note

Cette classe contient une demande de liaison et une demande d’héritage au niveau de la classe qui s’applique à tous les membres. Un SecurityException est levé lorsque l’appelant immédiat ou la classe dérivée n’a pas d’autorisation de confiance totale.

Constructeurs

Nom	Description
CodeCompiler()	Initialise une nouvelle instance de la classe CodeCompiler.

Propriétés

Nom	Description
CompilerName	Obtient le nom de l’exécutable du compilateur.
CurrentClass	Obtient la déclaration de type de code pour la classe active. (Hérité de CodeGenerator)
CurrentMember	Obtient le membre actuel de la classe. (Hérité de CodeGenerator)
CurrentMemberName	Obtient le nom du membre actuel. (Hérité de CodeGenerator)
CurrentTypeName	Obtient le nom de classe actuel. (Hérité de CodeGenerator)
FileExtension	Obtient l’extension de nom de fichier à utiliser pour les fichiers sources.
Indent	Obtient ou définit la quantité d’espaces à mettre en retrait chaque niveau de retrait. (Hérité de CodeGenerator)
IsCurrentClass	Obtient une valeur indiquant si l’objet actuel généré est une classe. (Hérité de CodeGenerator)
IsCurrentDelegate	Obtient une valeur indiquant si l’objet actuel généré est un délégué. (Hérité de CodeGenerator)
IsCurrentEnum	Obtient une valeur indiquant si l’objet actuel généré est une énumération. (Hérité de CodeGenerator)
IsCurrentInterface	Obtient une valeur indiquant si l’objet actuel généré est une interface. (Hérité de CodeGenerator)
IsCurrentStruct	Obtient une valeur indiquant si l’objet actuel généré est un type valeur ou un struct. (Hérité de CodeGenerator)
NullToken	Obtient le jeton qui représente null. (Hérité de CodeGenerator)
Options	Obtient les options à utiliser par le générateur de code. (Hérité de CodeGenerator)
Output	Obtient l’enregistreur de texte à utiliser pour la sortie. (Hérité de CodeGenerator)

Méthodes

Nom	Description
CmdArgsFromParameters(CompilerParameters)	Obtient les arguments de commande à passer au compilateur à partir du fichier spécifié CompilerParameters.
ContinueOnNewLine(String)	Génère un caractère de continuation de ligne et génère la chaîne spécifiée sur une nouvelle ligne. (Hérité de CodeGenerator)
CreateEscapedIdentifier(String)	Crée un identificateur d’échappement pour la valeur spécifiée. (Hérité de CodeGenerator)
CreateValidIdentifier(String)	Crée un identificateur valide pour la valeur spécifiée. (Hérité de CodeGenerator)
FromDom(CompilerParameters, CodeCompileUnit)	Compile l’unité de compilation spécifiée à l’aide des options spécifiées et retourne les résultats de la compilation.
FromDomBatch(CompilerParameters, CodeCompileUnit[])	Compile les unités de compilation spécifiées à l’aide des options spécifiées et retourne les résultats de la compilation.
FromFile(CompilerParameters, String)	Compile le fichier spécifié à l’aide des options spécifiées et retourne les résultats de la compilation.
FromFileBatch(CompilerParameters, String[])	Compile les fichiers spécifiés à l’aide des options spécifiées et retourne les résultats de la compilation.
FromSource(CompilerParameters, String)	Compile la chaîne de code source spécifiée à l’aide des options spécifiées et retourne les résultats de la compilation.
FromSourceBatch(CompilerParameters, String[])	Compile les chaînes de code source spécifiées à l’aide des options spécifiées et retourne les résultats de la compilation.
GenerateArgumentReferenceExpression(CodeArgumentReferenceExpression)	Génère du code pour l’expression de référence d’argument spécifié. (Hérité de CodeGenerator)
GenerateArrayCreateExpression(CodeArrayCreateExpression)	Génère du code pour l’expression de création de tableau spécifiée. (Hérité de CodeGenerator)
GenerateArrayIndexerExpression(CodeArrayIndexerExpression)	Génère du code pour l’expression d’indexeur de tableau spécifiée. (Hérité de CodeGenerator)
GenerateAssignStatement(CodeAssignStatement)	Génère du code pour l’instruction d’affectation spécifiée. (Hérité de CodeGenerator)
GenerateAttachEventStatement(CodeAttachEventStatement)	Génère du code pour l’instruction d’événement d’attachement spécifiée. (Hérité de CodeGenerator)
GenerateAttributeDeclarationsEnd(CodeAttributeDeclarationCollection)	Génère du code pour la fin de bloc d’attribut spécifiée. (Hérité de CodeGenerator)
GenerateAttributeDeclarationsStart(CodeAttributeDeclarationCollection)	Génère du code pour le démarrage du bloc d’attribut spécifié. (Hérité de CodeGenerator)
GenerateBaseReferenceExpression(CodeBaseReferenceExpression)	Génère du code pour l’expression de référence de base spécifiée. (Hérité de CodeGenerator)
GenerateBinaryOperatorExpression(CodeBinaryOperatorExpression)	Génère du code pour l’expression d’opérateur binaire spécifiée. (Hérité de CodeGenerator)
GenerateCastExpression(CodeCastExpression)	Génère du code pour l’expression de cast spécifiée. (Hérité de CodeGenerator)
GenerateCodeFromMember(CodeTypeMember, TextWriter, CodeGeneratorOptions)	Génère du code pour le membre de classe spécifié à l’aide des options du générateur de code et de l’enregistreur de texte spécifiés. (Hérité de CodeGenerator)
GenerateComment(CodeComment)	Génère du code pour le commentaire spécifié. (Hérité de CodeGenerator)
GenerateCommentStatement(CodeCommentStatement)	Génère du code pour l’instruction de commentaire spécifiée. (Hérité de CodeGenerator)
GenerateCommentStatements(CodeCommentStatementCollection)	Génère du code pour les instructions de commentaire spécifiées. (Hérité de CodeGenerator)
GenerateCompileUnit(CodeCompileUnit)	Génère du code pour l’unité de compilation spécifiée. (Hérité de CodeGenerator)
GenerateCompileUnitEnd(CodeCompileUnit)	Génère du code pour la fin d’une unité de compilation. (Hérité de CodeGenerator)
GenerateCompileUnitStart(CodeCompileUnit)	Génère du code pour le début d’une unité de compilation. (Hérité de CodeGenerator)
GenerateConditionStatement(CodeConditionStatement)	Génère du code pour l’instruction conditionnelle spécifiée. (Hérité de CodeGenerator)
GenerateConstructor(CodeConstructor, CodeTypeDeclaration)	Génère du code pour le constructeur spécifié. (Hérité de CodeGenerator)
GenerateDecimalValue(Decimal)	Génère du code pour la valeur décimale spécifiée. (Hérité de CodeGenerator)
GenerateDefaultValueExpression(CodeDefaultValueExpression)	Génère du code pour la référence spécifiée à une valeur par défaut. (Hérité de CodeGenerator)
GenerateDelegateCreateExpression(CodeDelegateCreateExpression)	Génère du code pour l’expression de création de délégué spécifiée. (Hérité de CodeGenerator)
GenerateDelegateInvokeExpression(CodeDelegateInvokeExpression)	Génère du code pour l’expression d’appel délégué spécifiée. (Hérité de CodeGenerator)
GenerateDirectionExpression(CodeDirectionExpression)	Génère du code pour l’expression de direction spécifiée. (Hérité de CodeGenerator)
GenerateDirectives(CodeDirectiveCollection)	Génère du code pour les directives de code spécifiées. (Hérité de CodeGenerator)
GenerateDoubleValue(Double)	Génère du code pour un nombre à virgule flottante double précision. (Hérité de CodeGenerator)
GenerateEntryPointMethod(CodeEntryPointMethod, CodeTypeDeclaration)	Génère du code pour la méthode de point d’entrée spécifiée. (Hérité de CodeGenerator)
GenerateEvent(CodeMemberEvent, CodeTypeDeclaration)	Génère du code pour l’événement spécifié. (Hérité de CodeGenerator)
GenerateEventReferenceExpression(CodeEventReferenceExpression)	Génère du code pour l’expression de référence d’événement spécifiée. (Hérité de CodeGenerator)
GenerateExpression(CodeExpression)	Génère du code pour l’expression de code spécifiée. (Hérité de CodeGenerator)
GenerateExpressionStatement(CodeExpressionStatement)	Génère du code pour l’instruction d’expression spécifiée. (Hérité de CodeGenerator)
GenerateField(CodeMemberField)	Génère du code pour le champ membre spécifié. (Hérité de CodeGenerator)
GenerateFieldReferenceExpression(CodeFieldReferenceExpression)	Génère du code pour l’expression de référence de champ spécifiée. (Hérité de CodeGenerator)
GenerateGotoStatement(CodeGotoStatement)	Génère du code pour l’instruction spécifiée goto . (Hérité de CodeGenerator)
GenerateIndexerExpression(CodeIndexerExpression)	Génère du code pour l’expression d’indexeur spécifiée. (Hérité de CodeGenerator)
GenerateIterationStatement(CodeIterationStatement)	Génère du code pour l’instruction d’itération spécifiée. (Hérité de CodeGenerator)
GenerateLabeledStatement(CodeLabeledStatement)	Génère du code pour l’instruction étiquetée spécifiée. (Hérité de CodeGenerator)
GenerateLinePragmaEnd(CodeLinePragma)	Génère du code pour la fin de pragma de ligne spécifiée. (Hérité de CodeGenerator)
GenerateLinePragmaStart(CodeLinePragma)	Génère du code pour le début de pragma de ligne spécifié. (Hérité de CodeGenerator)
GenerateMethod(CodeMemberMethod, CodeTypeDeclaration)	Génère du code pour la méthode spécifiée. (Hérité de CodeGenerator)
GenerateMethodInvokeExpression(CodeMethodInvokeExpression)	Génère du code pour l’expression d’appel de méthode spécifiée. (Hérité de CodeGenerator)
GenerateMethodReferenceExpression(CodeMethodReferenceExpression)	Génère du code pour l’expression de référence de méthode spécifiée. (Hérité de CodeGenerator)
GenerateMethodReturnStatement(CodeMethodReturnStatement)	Génère du code pour l’instruction de retour de méthode spécifiée. (Hérité de CodeGenerator)
GenerateNamespace(CodeNamespace)	Génère du code pour l’espace de noms spécifié. (Hérité de CodeGenerator)
GenerateNamespaceEnd(CodeNamespace)	Génère du code pour la fin d’un espace de noms. (Hérité de CodeGenerator)
GenerateNamespaceImport(CodeNamespaceImport)	Génère du code pour l’importation d’espace de noms spécifiée. (Hérité de CodeGenerator)
GenerateNamespaceImports(CodeNamespace)	Génère du code pour l’importation d’espace de noms spécifiée. (Hérité de CodeGenerator)
GenerateNamespaces(CodeCompileUnit)	Génère du code pour les espaces de noms dans l’unité de compilation spécifiée. (Hérité de CodeGenerator)
GenerateNamespaceStart(CodeNamespace)	Génère du code pour le début d’un espace de noms. (Hérité de CodeGenerator)
GenerateObjectCreateExpression(CodeObjectCreateExpression)	Génère du code pour l’expression de création d’objet spécifiée. (Hérité de CodeGenerator)
GenerateParameterDeclarationExpression(CodeParameterDeclarationExpression)	Génère du code pour l’expression de déclaration de paramètre spécifiée. (Hérité de CodeGenerator)
GeneratePrimitiveExpression(CodePrimitiveExpression)	Génère du code pour l’expression primitive spécifiée. (Hérité de CodeGenerator)
GenerateProperty(CodeMemberProperty, CodeTypeDeclaration)	Génère du code pour la propriété spécifiée. (Hérité de CodeGenerator)
GeneratePropertyReferenceExpression(CodePropertyReferenceExpression)	Génère du code pour l’expression de référence de propriété spécifiée. (Hérité de CodeGenerator)
GeneratePropertySetValueReferenceExpression(CodePropertySetValueReferenceExpression)	Génère du code pour l’expression de référence de valeur du jeu de propriétés spécifié. (Hérité de CodeGenerator)
GenerateRemoveEventStatement(CodeRemoveEventStatement)	Génère du code pour l’instruction d’événement remove spécifiée. (Hérité de CodeGenerator)
GenerateSingleFloatValue(Single)	Génère du code pour un nombre à virgule flottante simple précision. (Hérité de CodeGenerator)
GenerateSnippetCompileUnit(CodeSnippetCompileUnit)	Génère le code de l’unité de compilation de fragments de code littéral spécifié. (Hérité de CodeGenerator)
GenerateSnippetExpression(CodeSnippetExpression)	Génère le code de l’expression de fragment de code littéral spécifié. (Hérité de CodeGenerator)
GenerateSnippetMember(CodeSnippetTypeMember)	Génère le code du membre de classe de fragment de code littéral spécifié. (Hérité de CodeGenerator)
GenerateSnippetStatement(CodeSnippetStatement)	Génère le code de l’instruction de fragment de code littéral spécifié. (Hérité de CodeGenerator)
GenerateStatement(CodeStatement)	Génère du code pour l’instruction spécifiée. (Hérité de CodeGenerator)
GenerateStatements(CodeStatementCollection)	Génère du code pour la collection d’instructions spécifiée. (Hérité de CodeGenerator)
GenerateThisReferenceExpression(CodeThisReferenceExpression)	Génère du code pour l’expression de référence spécifiée. (Hérité de CodeGenerator)
GenerateThrowExceptionStatement(CodeThrowExceptionStatement)	Génère du code pour l’instruction d’exception throw spécifiée. (Hérité de CodeGenerator)
GenerateTryCatchFinallyStatement(CodeTryCatchFinallyStatement)	Génère du code pour l’instruction spécifiée try-catch-finally . (Hérité de CodeGenerator)
GenerateTypeConstructor(CodeTypeConstructor)	Génère du code pour le constructeur de classe spécifié. (Hérité de CodeGenerator)
GenerateTypeEnd(CodeTypeDeclaration)	Génère du code pour la fin spécifiée de la classe. (Hérité de CodeGenerator)
GenerateTypeOfExpression(CodeTypeOfExpression)	Génère du code pour le type d’expression spécifié. (Hérité de CodeGenerator)
GenerateTypeReferenceExpression(CodeTypeReferenceExpression)	Génère du code pour l’expression de référence de type spécifiée. (Hérité de CodeGenerator)
GenerateTypes(CodeNamespace)	Génère du code pour l’espace de noms spécifié et les classes qu’il contient. (Hérité de CodeGenerator)
GenerateTypeStart(CodeTypeDeclaration)	Génère du code pour le début spécifié de la classe. (Hérité de CodeGenerator)
GenerateVariableDeclarationStatement(CodeVariableDeclarationStatement)	Génère du code pour l’instruction de déclaration de variable spécifiée. (Hérité de CodeGenerator)
GenerateVariableReferenceExpression(CodeVariableReferenceExpression)	Génère du code pour l’expression de référence de variable spécifiée. (Hérité de CodeGenerator)
GetResponseFileCmdArgs(CompilerParameters, String)	Obtient les arguments de commande à utiliser lors de l’appel du compilateur pour générer un fichier réponse.
GetTypeOutput(CodeTypeReference)	Obtient le nom du type de données spécifié. (Hérité de CodeGenerator)
IsValidIdentifier(String)	Obtient une valeur indiquant si la valeur spécifiée est un identificateur valide. (Hérité de CodeGenerator)
JoinStringArray(String[], String)	Joint les tableaux de chaînes spécifiés.
OutputAttributeArgument(CodeAttributeArgument)	Génère un argument dans un bloc d’attributs. (Hérité de CodeGenerator)
OutputAttributeDeclarations(CodeAttributeDeclarationCollection)	Génère du code pour la collection de déclarations d’attributs spécifiée. (Hérité de CodeGenerator)
OutputDirection(FieldDirection)	Génère du code pour le fichier spécifié FieldDirection. (Hérité de CodeGenerator)
OutputExpressionList(CodeExpressionCollection, Boolean)	Génère du code pour la liste d’expressions spécifiée. (Hérité de CodeGenerator)
OutputExpressionList(CodeExpressionCollection)	Génère du code pour la liste d’expressions spécifiée. (Hérité de CodeGenerator)
OutputFieldScopeModifier(MemberAttributes)	Génère un modificateur d’étendue de champ qui correspond aux attributs spécifiés. (Hérité de CodeGenerator)
OutputIdentifier(String)	Génère l’identificateur spécifié. (Hérité de CodeGenerator)
OutputMemberAccessModifier(MemberAttributes)	Génère du code pour le modificateur d’accès membre spécifié. (Hérité de CodeGenerator)
OutputMemberScopeModifier(MemberAttributes)	Génère du code pour le modificateur d’étendue de membre spécifié. (Hérité de CodeGenerator)
OutputOperator(CodeBinaryOperatorType)	Génère du code pour l’opérateur spécifié. (Hérité de CodeGenerator)
OutputParameters(CodeParameterDeclarationExpressionCollection)	Génère du code pour les paramètres spécifiés. (Hérité de CodeGenerator)
OutputType(CodeTypeReference)	Génère du code pour le type spécifié. (Hérité de CodeGenerator)
OutputTypeAttributes(TypeAttributes, Boolean, Boolean)	Génère du code pour les attributs de type spécifiés. (Hérité de CodeGenerator)
OutputTypeNamePair(CodeTypeReference, String)	Génère du code pour le type d’objet et la paire de noms spécifiés. (Hérité de CodeGenerator)
ProcessCompilerOutputLine(CompilerResults, String)	Traite la ligne spécifiée à partir de l’objet spécifié CompilerResults.
QuoteSnippetString(String)	Convertit la chaîne spécifiée en la mettant en forme avec des codes d’échappement. (Hérité de CodeGenerator)
Supports(GeneratorSupport)	Obtient une valeur indiquant si la prise en charge de la génération de code spécifiée est fournie. (Hérité de CodeGenerator)
ValidateIdentifier(String)	Lève une exception si la chaîne spécifiée n’est pas un identificateur valide. (Hérité de CodeGenerator)

Implémentations d’interfaces explicites

Nom	Description
ICodeCompiler.CompileAssemblyFromDom(CompilerParameters, CodeCompileUnit)	Pour obtenir une description de ce membre, consultez CompileAssemblyFromDom(CompilerParameters, CodeCompileUnit).
ICodeCompiler.CompileAssemblyFromDomBatch(CompilerParameters, CodeCompileUnit[])	Pour obtenir une description de ce membre, consultez CompileAssemblyFromDomBatch(CompilerParameters, CodeCompileUnit[]).
ICodeCompiler.CompileAssemblyFromFile(CompilerParameters, String)	Pour obtenir une description de ce membre, consultez CompileAssemblyFromFile(CompilerParameters, String).
ICodeCompiler.CompileAssemblyFromFileBatch(CompilerParameters, String[])	Pour obtenir une description de ce membre, consultez CompileAssemblyFromFileBatch(CompilerParameters, String[]).
ICodeCompiler.CompileAssemblyFromSource(CompilerParameters, String)	Pour obtenir une description de ce membre, consultez CompileAssemblyFromSource(CompilerParameters, String).
ICodeCompiler.CompileAssemblyFromSourceBatch(CompilerParameters, String[])	Pour obtenir une description de ce membre, consultez CompileAssemblyFromSourceBatch(CompilerParameters, String[]).
ICodeGenerator.CreateEscapedIdentifier(String)	Crée un identificateur d’échappement pour la valeur spécifiée. (Hérité de CodeGenerator)
ICodeGenerator.CreateValidIdentifier(String)	Crée un identificateur valide pour la valeur spécifiée. (Hérité de CodeGenerator)
ICodeGenerator.GenerateCodeFromCompileUnit(CodeCompileUnit, TextWriter, CodeGeneratorOptions)	Génère du code pour l’unité de compilation Code Document Object Model (CodeDOM) spécifiée et la génère vers l’enregistreur de texte spécifié à l’aide des options spécifiées. (Hérité de CodeGenerator)
ICodeGenerator.GenerateCodeFromExpression(CodeExpression, TextWriter, CodeGeneratorOptions)	Génère du code pour l’expression Code Document Object Model (CodeDOM) spécifiée et la génère dans l’enregistreur de texte spécifié. (Hérité de CodeGenerator)
ICodeGenerator.GenerateCodeFromNamespace(CodeNamespace, TextWriter, CodeGeneratorOptions)	Génère du code pour l’espace de noms Code Document Object Model (CodeDOM) spécifié et le génère vers l’enregistreur de texte spécifié à l’aide des options spécifiées. (Hérité de CodeGenerator)
ICodeGenerator.GenerateCodeFromStatement(CodeStatement, TextWriter, CodeGeneratorOptions)	Génère du code pour l’instruction Code Document Object Model (CodeDOM) spécifiée et la génère vers l’enregistreur de texte spécifié à l’aide des options spécifiées. (Hérité de CodeGenerator)
ICodeGenerator.GenerateCodeFromType(CodeTypeDeclaration, TextWriter, CodeGeneratorOptions)	Génère du code pour la déclaration de type Code Document Object Model (CodeDOM) spécifiée et la génère dans l’enregistreur de texte spécifié à l’aide des options spécifiées. (Hérité de CodeGenerator)
ICodeGenerator.GetTypeOutput(CodeTypeReference)	Obtient le type indiqué par le .CodeTypeReference (Hérité de CodeGenerator)
ICodeGenerator.IsValidIdentifier(String)	Obtient une valeur qui indique si la valeur spécifiée est un identificateur valide pour la langue actuelle. (Hérité de CodeGenerator)
ICodeGenerator.Supports(GeneratorSupport)	Obtient une valeur indiquant si le générateur prend en charge les fonctionnalités de langage représentées par l’objet spécifié GeneratorSupport . (Hérité de CodeGenerator)
ICodeGenerator.ValidateIdentifier(String)	Lève une exception si la valeur spécifiée n’est pas un identificateur valide. (Hérité de CodeGenerator)

Voir aussi

• ICodeCompiler
• CompilerParameters
• CompilerResults