CodeDomProvider Klasse

Definition

Namespace:

System.CodeDom.Compiler

Assembly:

System.CodeDom.dll

Paket:

System.CodeDom v9.0.0-rc.1.24431.7

Quelle:

CodeDomProvider.cs

Stellt eine Basisklasse für CodeDomProvider-Implementierungen bereit. Diese Klasse ist abstrakt.

C#

public abstract class CodeDomProvider : System.ComponentModel.Component

Vererbung

Object

MarshalByRefObject

Component

CodeDomProvider

Abgeleitet

Microsoft.CSharp.CSharpCodeProvider

Microsoft.JScript.JScriptCodeProvider

Microsoft.VisualBasic.VBCodeProvider

Beispiele

Das folgende Beispielprogramm kann Quellcode basierend auf einem CodeDOM-Modell eines Programms generieren und kompilieren, das "Hello World" mithilfe der Console -Klasse ausgibt. Eine Windows Forms-Benutzeroberfläche wird bereitgestellt. Der Benutzer kann die Zielprogrammiersprache aus mehreren Auswahlmöglichkeiten auswählen: C#, Visual Basic und JScript.

C#

using System;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Collections;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Windows.Forms;
using Microsoft.CSharp;
using Microsoft.VisualBasic;
using Microsoft.JScript;

// This example demonstrates building a Hello World program graph
// using System.CodeDom elements. It calls code generator and
// code compiler methods to build the program using CSharp, VB, or
// JScript.  A Windows Forms interface is included. Note: Code
// must be compiled and linked with the Microsoft.JScript assembly.
namespace CodeDOMExample
{
    class CodeDomExample
    {
        // Build a Hello World program graph using
        // System.CodeDom types.
        public static CodeCompileUnit BuildHelloWorldGraph()
        {
            // Create a new CodeCompileUnit to contain
            // the program graph.
            CodeCompileUnit compileUnit = new CodeCompileUnit();

            // Declare a new namespace called Samples.
            CodeNamespace samples = new CodeNamespace("Samples");
            // Add the new namespace to the compile unit.
            compileUnit.Namespaces.Add(samples);

            // Add the new namespace import for the System namespace.
            samples.Imports.Add(new CodeNamespaceImport("System"));

            // Declare a new type called Class1.
            CodeTypeDeclaration class1 = new CodeTypeDeclaration("Class1");
            // Add the new type to the namespace type collection.
            samples.Types.Add(class1);

            // Declare a new code entry point method.
            CodeEntryPointMethod start = new CodeEntryPointMethod();

            // Create a type reference for the System.Console class.
            CodeTypeReferenceExpression csSystemConsoleType = new CodeTypeReferenceExpression("System.Console");

            // Build a Console.WriteLine statement.
            CodeMethodInvokeExpression cs1 = new CodeMethodInvokeExpression(
                csSystemConsoleType, "WriteLine",
                new CodePrimitiveExpression("Hello World!"));

            // Add the WriteLine call to the statement collection.
            start.Statements.Add(cs1);

            // Build another Console.WriteLine statement.
            CodeMethodInvokeExpression cs2 = new CodeMethodInvokeExpression(
                csSystemConsoleType, "WriteLine",
                new CodePrimitiveExpression("Press the Enter key to continue."));

            // Add the WriteLine call to the statement collection.
            start.Statements.Add(cs2);

            // Build a call to System.Console.ReadLine.
            CodeMethodInvokeExpression csReadLine = new CodeMethodInvokeExpression(
                csSystemConsoleType, "ReadLine");

            // Add the ReadLine statement.
            start.Statements.Add(csReadLine);

            // Add the code entry point method to
            // the Members collection of the type.
            class1.Members.Add(start);

            return compileUnit;
        }

        public static void GenerateCode(CodeDomProvider provider,
            CodeCompileUnit compileunit)
        {
            // Build the source file name with the appropriate
            // language extension.
            String sourceFile;
            if (provider.FileExtension[0] == '.')
            {
                sourceFile = "TestGraph" + provider.FileExtension;
            }
            else
            {
                sourceFile = "TestGraph." + provider.FileExtension;
            }

            // Create an IndentedTextWriter, constructed with
            // a StreamWriter to the source file.
            IndentedTextWriter tw = new IndentedTextWriter(new StreamWriter(sourceFile, false), "    ");
            // Generate source code using the code generator.
            provider.GenerateCodeFromCompileUnit(compileunit, tw, new CodeGeneratorOptions());
            // Close the output file.
            tw.Close();
        }

        public static CompilerResults CompileCode(CodeDomProvider provider,
                                                  String sourceFile,
                                                  String exeFile)
        {
            // Configure a CompilerParameters that links System.dll
            // and produces the specified executable file.
            String[] referenceAssemblies = { "System.dll" };
            CompilerParameters cp = new CompilerParameters(referenceAssemblies,
                                                           exeFile, false);
            // Generate an executable rather than a DLL file.
            cp.GenerateExecutable = true;

            // Invoke compilation.
            CompilerResults cr = provider.CompileAssemblyFromFile(cp, sourceFile);
            // Return the results of compilation.
            return cr;
        }
    }

    public class CodeDomExampleForm : System.Windows.Forms.Form
    {
        private System.Windows.Forms.Button run_button = new System.Windows.Forms.Button();
        private System.Windows.Forms.Button compile_button = new System.Windows.Forms.Button();
        private System.Windows.Forms.Button generate_button = new System.Windows.Forms.Button();
        private System.Windows.Forms.TextBox textBox1 = new System.Windows.Forms.TextBox();
        private System.Windows.Forms.ComboBox comboBox1 = new System.Windows.Forms.ComboBox();
        private System.Windows.Forms.Label label1 = new System.Windows.Forms.Label();

        private void generate_button_Click(object sender, System.EventArgs e)
        {
            CodeDomProvider provider = GetCurrentProvider();
            CodeDomExample.GenerateCode(provider, CodeDomExample.BuildHelloWorldGraph());

            // Build the source file name with the appropriate
            // language extension.
            String sourceFile;
            if (provider.FileExtension[0] == '.')
            {
                sourceFile = "TestGraph" + provider.FileExtension;
            }
            else
            {
                sourceFile = "TestGraph." + provider.FileExtension;
            }

            // Read in the generated source file and
            // display the source text.
            StreamReader sr = new StreamReader(sourceFile);
            textBox1.Text = sr.ReadToEnd();
            sr.Close();
        }

        private void compile_button_Click(object sender, System.EventArgs e)
        {
            CodeDomProvider provider = GetCurrentProvider();

            // Build the source file name with the appropriate
            // language extension.
            String sourceFile;
            if (provider.FileExtension[0] == '.')
            {
                sourceFile = "TestGraph" + provider.FileExtension;
            }
            else
            {
                sourceFile = "TestGraph." + provider.FileExtension;
            }

            // Compile the source file into an executable output file.
            CompilerResults cr = CodeDomExample.CompileCode(provider,
                                                            sourceFile,
                                                            "TestGraph.exe");

            if (cr.Errors.Count > 0)
            {
                // Display compilation errors.
                textBox1.Text = "Errors encountered while building " +
                                sourceFile + " into " + cr.PathToAssembly + ": \r\n\n";
                foreach (CompilerError ce in cr.Errors)
                    textBox1.AppendText(ce.ToString() + "\r\n");
                run_button.Enabled = false;
            }
            else
            {
                textBox1.Text = "Source " + sourceFile + " built into " +
                                cr.PathToAssembly + " with no errors.";
                run_button.Enabled = true;
            }
        }

        private void run_button_Click(object sender,
            System.EventArgs e)
        {
            Process.Start("TestGraph.exe");
        }

        private CodeDomProvider GetCurrentProvider()
        {
            CodeDomProvider provider;
            switch ((string)this.comboBox1.SelectedItem)
            {
                case "CSharp":
                    provider = CodeDomProvider.CreateProvider("CSharp");
                    break;
                case "Visual Basic":
                    provider = CodeDomProvider.CreateProvider("VisualBasic");
                    break;
                case "JScript":
                    provider = CodeDomProvider.CreateProvider("JScript");
                    break;
                default:
                    provider = CodeDomProvider.CreateProvider("CSharp");
                    break;
            }
            return provider;
        }

        public CodeDomExampleForm()
        {
            this.SuspendLayout();
            // Set properties for label1
            this.label1.Location = new System.Drawing.Point(395, 20);
            this.label1.Size = new Size(180, 22);
            this.label1.Text = "Select a programming language:";
            // Set properties for comboBox1
            this.comboBox1.Location = new System.Drawing.Point(560, 16);
            this.comboBox1.Size = new Size(190, 23);
            this.comboBox1.Name = "comboBox1";
            this.comboBox1.Items.AddRange(new string[] { "CSharp", "Visual Basic", "JScript" });
            this.comboBox1.Anchor = System.Windows.Forms.AnchorStyles.Left
                                    | System.Windows.Forms.AnchorStyles.Right
                                    | System.Windows.Forms.AnchorStyles.Top;
            this.comboBox1.SelectedIndex = 0;
            // Set properties for generate_button.
            this.generate_button.Location = new System.Drawing.Point(8, 16);
            this.generate_button.Name = "generate_button";
            this.generate_button.Size = new System.Drawing.Size(120, 23);
            this.generate_button.Text = "Generate Code";
            this.generate_button.Click += new System.EventHandler(this.generate_button_Click);
            // Set properties for compile_button.
            this.compile_button.Location = new System.Drawing.Point(136, 16);
            this.compile_button.Name = "compile_button";
            this.compile_button.Size = new System.Drawing.Size(120, 23);
            this.compile_button.Text = "Compile";
            this.compile_button.Click += new System.EventHandler(this.compile_button_Click);
            // Set properties for run_button.
            this.run_button.Enabled = false;
            this.run_button.Location = new System.Drawing.Point(264, 16);
            this.run_button.Name = "run_button";
            this.run_button.Size = new System.Drawing.Size(120, 23);
            this.run_button.Text = "Run";
            this.run_button.Click += new System.EventHandler(this.run_button_Click);
            // Set properties for textBox1.
            this.textBox1.Anchor = (System.Windows.Forms.AnchorStyles.Top
                                     | System.Windows.Forms.AnchorStyles.Bottom
                                     | System.Windows.Forms.AnchorStyles.Left
                                     | System.Windows.Forms.AnchorStyles.Right);
            this.textBox1.Location = new System.Drawing.Point(8, 48);
            this.textBox1.Multiline = true;
            this.textBox1.ScrollBars = System.Windows.Forms.ScrollBars.Vertical;
            this.textBox1.Name = "textBox1";
            this.textBox1.Size = new System.Drawing.Size(744, 280);
            this.textBox1.Text = "";
            // Set properties for the CodeDomExampleForm.
            this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
            this.ClientSize = new System.Drawing.Size(768, 340);
            this.MinimumSize = new System.Drawing.Size(750, 340);
            this.Controls.AddRange(new System.Windows.Forms.Control[] {this.textBox1,
                this.run_button, this.compile_button, this.generate_button,
                this.comboBox1, this.label1 });
            this.Name = "CodeDomExampleForm";
            this.Text = "CodeDom Hello World Example";
            this.ResumeLayout(false);
        }

        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
        }

        [STAThread]
        static void Main()
        {
            Application.Run(new CodeDomExampleForm());
        }
    }
}

Hinweise

Ein CodeDomProvider kann verwendet werden, um Instanzen von Codegeneratoren und Codecompilern zu erstellen und abzurufen. Mit Code-Generatoren kann Code in bestimmten Sprachen erstellt werden. Mit Codecompilern kann Code in Assemblys kompiliert werden.

Hinweis

In .NET Framework 2.0 sind die Methoden, die im Codegenerator und Codecompiler zur Verfügung gestellt werden, direkt über den Codeanbieter verfügbar. Sie müssen oder CreateCompiler nicht aufrufenCreateGenerator, um auf die Methoden zuzugreifen, und diese Methoden sind als veraltet markiert. Dies gilt sowohl für bereits vorhandene als auch für neue Codeanbieterimplementierungen.

Eine CodeDomProvider Implementierung bietet in der Regel Codegenerierungs- und/oder Codekompilierungsschnittstellen zum Generieren von Code und zum Verwalten der Kompilierung für eine einzelne Programmiersprache. Mehrere Sprachen werden von CodeDomProvider Implementierungen unterstützt, die im Lieferumfang des Windows SDK enthalten sind. Zu diesen Sprachen gehören C#, Visual Basic, C++ und JScript. Entwickler oder Compileranbieter können die ICodeGenerator Schnittstellen und ICodeCompiler implementieren und eine CodeDomProvider bereitstellen, die codeDOM-Unterstützung auf andere Programmiersprachen erweitert.

Das <system.codedom-Element> in der Computerkonfigurationsdatei (Machine.config) bietet Entwicklern und Compilerherstellern einen Mechanismus zum Hinzufügen von Konfigurationseinstellungen für zusätzliche CodeDomProvider Implementierungen.

Die CodeDomProvider -Klasse stellt statische Methoden bereit, um die CodeDomProvider Implementierungen auf einem Computer zu ermitteln und aufzulisten. Die GetAllCompilerInfo -Methode gibt die Einstellungen für alle CodeDomProvider Implementierungen auf einem Computer zurück. Die GetCompilerInfo -Methode gibt die Einstellungen für eine bestimmte CodeDomProvider Implementierung basierend auf dem Namen der Programmiersprache zurück. Die CreateProvider -Methode gibt eine Instanz einer CodeDomProvider Implementierung für eine bestimmte Sprache zurück.

Weitere Informationen zu Den Einstellungen des Sprachanbieters in der Konfigurationsdatei finden Sie unter Schema für Compiler- und Sprachanbietereinstellungen.

Hinweis

Diese Klasse stellt eine Linkanforderung und eine Vererbungsanforderung auf Klassenebene her. Ein SecurityException wird ausgelöst, wenn entweder der unmittelbare Aufrufer oder die abgeleitete Klasse nicht über voll vertrauenswürdige Berechtigungen verfügt. Ausführliche Informationen zu Sicherheitsanforderungen finden Sie unter Linkanforderungen und Vererbungsanforderungen.

Hinweise für Ausführende

In den .NET Framework-Versionen 1.0 und 1.1 bestehen Codeanbieter aus Implementierungen von CodeDomProvider, ICodeGenerator, ICodeParserund ICodeCompiler. In .NET Framework 2.0 sind die CreateGenerator()Methoden , CreateParser()und CreateCompiler() veraltet, und die Methoden von ICodeGenerator und ICodeCompiler sind direkt in der CodeDomProvider -Klasse verfügbar. Sie sollten diese Methoden in Ihrer Codeanbieterimplementierung überschreiben und die Basismethoden nicht aufrufen.

Konstruktoren

CodeDomProvider()

Initialisiert eine neue Instanz der CodeDomProvider-Klasse.

Eigenschaften

CanRaiseEvents	Ruft einen Wert ab, der angibt, ob die Komponente ein Ereignis auslösen kann. (Geerbt von Component)
Container	Ruft die IContainer ab, die in der Component enthalten ist. (Geerbt von Component)
DesignMode	Ruft einen Wert ab, der angibt, ob sich Component gegenwärtig im Entwurfsmodus befindet. (Geerbt von Component)
Events	Ruft die Liste der Ereignishandler ab, die dieser Component angefügt sind. (Geerbt von Component)
FileExtension	Ruft die Standarddateinamenerweiterung ab, die für Quellcodedateien in der aktuellen Sprache verwendet werden soll.
LanguageOptions	Ruft einen Bezeichner für Sprachfeatures ab.
Site	Ruft den ISite von Component ab oder legt ihn fest. (Geerbt von Component)

Methoden

CompileAssemblyFromDom(CompilerParameters, CodeCompileUnit[])	Kompiliert eine Assembly auf Grundlage der System.CodeDom-Strukturen im angegebenen Array von CodeCompileUnit-Objekten mit den angegebenen Compilereinstellungen.
CompileAssemblyFromFile(CompilerParameters, String[])	Kompiliert eine Assembly aus dem in den angegebenen Dateien enthaltenen Quellcode mit den angegebenen Compilereinstellungen.
CompileAssemblyFromSource(CompilerParameters, String[])	Kompiliert eine Assembly aus dem angegebenen Array von Zeichenfolgen mit Quellcode und unter Verwendung der angegebenen Compilereinstellungen.
CreateCompiler()	Veraltet. Erstellt beim Überschreiben in einer abgeleiteten Klasse einen neuen Codecompiler.
CreateEscapedIdentifier(String)	Erstellt einen mit einem Escapezeichen versehenen Bezeichner für den angegebenen Wert.
CreateGenerator()	Veraltet. Erstellt beim Überschreiben in einer abgeleiteten Klasse einen neuen Codegenerator.
CreateGenerator(String)	Erstellt beim Überschreiben in einer abgeleiteten Klasse einen neuen Codegenerator unter Verwendung des angegebenen Dateinamens für die Ausgabe.
CreateGenerator(TextWriter)	Erstellt beim Überschreiben in einer abgeleiteten Klasse einen neuen Codegenerator unter Verwendung des angegebenen TextWriter für die Ausgabe.
CreateObjRef(Type)	Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind. (Geerbt von MarshalByRefObject)
CreateParser()	Veraltet. Erstellt beim Überschreiben in einer abgeleiteten Klasse einen neuen Codeparser.
CreateProvider(String)	Ruft eine CodeDomProvider-Instanz für die angegebene Sprache ab.
CreateProvider(String, IDictionary<String,String>)	Ruft eine CodeDomProvider-Instanz für die angegebenen Sprach- und Anbieteroptionen ab.
CreateValidIdentifier(String)	Erstellt einen gültigen Bezeichner für den angegebenen Wert.
Dispose()	Gibt alle vom Component verwendeten Ressourcen frei. (Geerbt von Component)
Dispose(Boolean)	Gibt die von Component verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei. (Geerbt von Component)
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GenerateCodeFromCompileUnit(CodeCompileUnit, TextWriter, CodeGeneratorOptions)	Generiert Code für die angegebene CodeDOM-Kompilierungseinheit (Code Document Object Model) und sendet diesen mit den angegebenen Optionen an den angegebenen Textwriter.
GenerateCodeFromExpression(CodeExpression, TextWriter, CodeGeneratorOptions)	Generiert Code für den angegebenen CodeDOM-Ausdruck (Code Document Object Model) und sendet diesen mit den angegebenen Optionen an den angegebenen Textwriter.
GenerateCodeFromMember(CodeTypeMember, TextWriter, CodeGeneratorOptions)	Generiert Code für die angegebene CodeDOM-Memberdeklaration (Code Document Object Model) und sendet diesen mit den angegebenen Optionen an den angegebenen Textwriter.
GenerateCodeFromNamespace(CodeNamespace, TextWriter, CodeGeneratorOptions)	Generiert Code für den angegebenen CodeDOM-Namespace (Code Document Object Model) und sendet diesen mit den angegebenen Optionen an den angegebenen Textwriter.
GenerateCodeFromStatement(CodeStatement, TextWriter, CodeGeneratorOptions)	Generiert Code für die angegebene CodeDOM-Anweisung (Code Document Object Model) und sendet diesen mit den angegebenen Optionen an den angegebenen Textwriter.
GenerateCodeFromType(CodeTypeDeclaration, TextWriter, CodeGeneratorOptions)	Generiert Code für die angegebene CodeDOM-Typdeklaration (Code Document Object Model) und sendet diesen mit den angegebenen Optionen an den angegebenen Textwriter.
GetAllCompilerInfo()	Gibt den Sprachanbieter und die Compilerkonfigurationseinstellungen für diesen Computer zurück.
GetCompilerInfo(String)	Gibt die Sprachanbieter- und Compilerkonfigurationseinstellungen für die angegebene Sprache zurück.
GetConverter(Type)	Ruft einen TypeConverter für den angegebenen Datentyp ab.
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetLanguageFromExtension(String)	Gibt, wie im CodeDomProvider-Compilerkonfigurationsabschnitt konfiguriert, einen der angegebenen Dateinamenerweiterung zugeordneten Sprachnamen zurück.
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetService(Type)	Gibt ein Objekt zurück, das einen von der Component oder von deren Container bereitgestellten Dienst darstellt. (Geerbt von Component)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
GetTypeOutput(CodeTypeReference)	Ruft den durch die angegebene CodeTypeReference angegebenen Typ ab.
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab. (Geerbt von MarshalByRefObject)
IsDefinedExtension(String)	Testet, ob eine Dateinamenerweiterung über eine ihr zugeordnete, auf dem Computer konfigurierte CodeDomProvider-Implementierung verfügt.
IsDefinedLanguage(String)	Testet, ob eine Sprache über eine auf dem Computer konfigurierte CodeDomProvider-Implementierung verfügt.
IsValidIdentifier(String)	Gibt einen Wert zurück, der angibt, ob der angegebene Wert ein gültiger Bezeichner für die aktuelle Sprache ist.
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
Parse(TextReader)	Kompiliert den aus dem angegebenen Textstream gelesenen Code in einer CodeCompileUnit.
Supports(GeneratorSupport)	Gibt einen Wert zurück, der angibt, ob die angegebene Unterstützung für die Codegenerierung verfügbar ist.
ToString()	Gibt einen String zurück, der den Namen der Component enthält (sofern vorhanden). Diese Methode darf nicht überschrieben werden. (Geerbt von Component)

Ereignisse

Disposed

Tritt auf, wenn die Komponente von einem Aufruf der Dispose()-Methode verworfen wird. (Geerbt von Component)

Gilt für:

Weitere Informationen

• CompilerInfo
• CSharpCodeProvider
• VBCodeProvider
• JScriptCodeProvider
• Compiler and Language Provider Settings Schema (Schema für Compiler- und Sprachanbietereinstellungen)