Freigeben über


CSharpCodeProvider Klasse

Definition

Stellt den Zugriff auf Instanzen des C#-Code-Generators und des C#-Codecompilers bereit.

public ref class CSharpCodeProvider : System::CodeDom::Compiler::CodeDomProvider
public class CSharpCodeProvider : System.CodeDom.Compiler.CodeDomProvider
type CSharpCodeProvider = class
    inherit CodeDomProvider
Public Class CSharpCodeProvider
Inherits CodeDomProvider
Vererbung

Beispiele

Im folgenden Beispiel wird entweder der C#- oder Visual Basic-Codeanbieter verwendet, um eine Quelldatei zu kompilieren. Im Beispiel wird die Eingabedateierweiterung überprüft und die entsprechende CSharpCodeProvider oder VBCodeProvider für die Kompilierung verwendet. Die Eingabedatei wird in eine ausführbare Datei kompiliert, und alle Kompilierungsfehler werden in der Konsole angezeigt.

using System;
using System.IO;
using System.Globalization;
using System.CodeDom.Compiler;
using System.Text;
using Microsoft.CSharp;
using Microsoft.VisualBasic;

namespace CodeProviders
{
    class CompileSample
    {
        [STAThread]
        static void Main(string[] args)
        {
            if (args.Length > 0)
            {
                //  First parameter is the source file name.
                if (File.Exists(args[0]))
                {
                    CompileExecutable(args[0]);
                }
                else
                {
                    Console.WriteLine("Input source file not found - {0}",
                        args[0]);
                }
            }
            else
            {
                Console.WriteLine("Input source file not specified on command line!");
            }
        }

        public static bool CompileExecutable(String sourceName)
        {
            FileInfo sourceFile = new FileInfo(sourceName);
            CodeDomProvider provider = null;
            bool compileOk = false;

            // Select the code provider based on the input file extension.
            if (sourceFile.Extension.ToUpper(CultureInfo.InvariantCulture) == ".CS")
            {
                provider = CodeDomProvider.CreateProvider("CSharp");
            }
            else if (sourceFile.Extension.ToUpper(CultureInfo.InvariantCulture) == ".VB")
            {
                provider = CodeDomProvider.CreateProvider("VisualBasic");
            }
            else
            {
                Console.WriteLine("Source file must have a .cs or .vb extension");
            }

            if (provider != null)
            {

                // Format the executable file name.
                // Build the output assembly path using the current directory
                // and <source>_cs.exe or <source>_vb.exe.

                String exeName = String.Format(@"{0}\{1}.exe",
                    System.Environment.CurrentDirectory,
                    sourceFile.Name.Replace(".", "_"));

                CompilerParameters cp = new CompilerParameters();

                // Generate an executable instead of
                // a class library.
                cp.GenerateExecutable = true;

                // Specify the assembly file name to generate.
                cp.OutputAssembly = exeName;

                // Save the assembly as a physical file.
                cp.GenerateInMemory = false;

                // Set whether to treat all warnings as errors.
                cp.TreatWarningsAsErrors = false;

                // Invoke compilation of the source file.
                CompilerResults cr = provider.CompileAssemblyFromFile(cp,
                    sourceName);

                if(cr.Errors.Count > 0)
                {
                    // Display compilation errors.
                    Console.WriteLine("Errors building {0} into {1}",
                        sourceName, cr.PathToAssembly);
                    foreach(CompilerError ce in cr.Errors)
                    {
                        Console.WriteLine("  {0}", ce.ToString());
                        Console.WriteLine();
                    }
                }
                else
                {
                    // Display a successful compilation message.
                    Console.WriteLine("Source {0} built into {1} successfully.",
                        sourceName, cr.PathToAssembly);
                }

                // Return the results of the compilation.
                if (cr.Errors.Count > 0)
                {
                    compileOk = false;
                }
                else
                {
                    compileOk = true;
                }
            }
            return compileOk;
        }
    }
}
Imports System.IO
Imports System.Globalization
Imports System.CodeDom.Compiler
Imports System.Text
Imports Microsoft.CSharp

Namespace CodeProviders
    Class CompileSample
        <STAThread()>  _
        Public Shared Sub Main(args() As String)

            If args.Length > 0
                ' First parameter is the source file name.
                If File.Exists(args(0))
                    CompileExecutable(args(0))
                Else 
                    Console.WriteLine("Input source file not found - {0}", _
                        args(0))
                End If
            
            Else
                Console.WriteLine("Input source file not specified on command line!")
            End If
        End Sub

        Public Shared Function CompileExecutable(sourceName As String) As Boolean
            Dim sourceFile As FileInfo = New FileInfo(sourceName)
            Dim provider As CodeDomProvider = Nothing
            Dim compileOk As Boolean = False

            ' Select the code provider based on the input file extension.
            If sourceFile.Extension.ToUpper(CultureInfo.InvariantCulture) = ".CS"

                provider = CodeDomProvider.CreateProvider("CSharp")

            ElseIf sourceFile.Extension.ToUpper(CultureInfo.InvariantCulture) = ".VB"

                provider = CodeDomProvider.CreateProvider("VisualBasic")

            Else
                Console.WriteLine("Source file must have a .cs or .vb extension")
            End If

            If Not provider Is Nothing

                ' Format the executable file name.
                ' Build the output assembly path using the current directory
                ' and <source>_cs.exe or <source>_vb.exe.

                Dim exeName As String = String.Format("{0}\{1}.exe", _
                    System.Environment.CurrentDirectory, _
                    sourceFile.Name.Replace(".", "_"))

                Dim cp As CompilerParameters = new CompilerParameters()

                ' Generate an executable instead of 
                ' a class library.
                cp.GenerateExecutable = True

                ' Specify the assembly file name to generate.
                cp.OutputAssembly = exeName
    
                ' Save the assembly as a physical file.
                cp.GenerateInMemory = False
    
                ' Set whether to treat all warnings as errors.
                cp.TreatWarningsAsErrors = False
 
                ' Invoke compilation of the source file.
                Dim cr As CompilerResults = provider.CompileAssemblyFromFile(cp, _
                    sourceName)
    
                If cr.Errors.Count > 0
                    ' Display compilation errors.
                    Console.WriteLine("Errors building {0} into {1}", _
                        sourceName, cr.PathToAssembly)

                    Dim ce As CompilerError
                    For Each ce In cr.Errors
                        Console.WriteLine("  {0}", ce.ToString())
                        Console.WriteLine()
                    Next ce
                Else
                    ' Display a successful compilation message.
                    Console.WriteLine("Source {0} built into {1} successfully.", _
                        sourceName, cr.PathToAssembly)
                End If
              
                ' Return the results of the compilation.
                If cr.Errors.Count > 0
                    compileOk = False
                Else 
                    compileOk = True
                End If
            End If
            return compileOk

        End Function
    End Class
End Namespace

Hinweise

Diese Klasse stellt Methoden bereit, die zum Abrufen von C#- ICodeGenerator Instanzen und ICodeCompiler Implementierungen verwendet werden können.

Hinweis

Diese Klasse enthält eine Linkanforderung und eine Vererbungsanforderung auf Klassenebene, die für alle Member gilt. Ein SecurityException wird ausgelöst, wenn entweder der unmittelbare Aufrufer oder die abgeleitete Klasse keine voll vertrauenswürdige Berechtigung hat.

Konstruktoren

CSharpCodeProvider()

Initialisiert eine neue Instanz der CSharpCodeProvider-Klasse.

CSharpCodeProvider(IDictionary<String,String>)

Initialisiert eine neue Instanz der CSharpCodeProvider-Klasse mit den angegebenen Anbieteroptionen.

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 beim Erstellen von Quellcodedateien zu verwendende Dateinamenerweiterung ab.

LanguageOptions

Ruft einen Bezeichner für Sprachfeatures ab.

(Geerbt von CodeDomProvider)
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.

(Geerbt von CodeDomProvider)
CompileAssemblyFromFile(CompilerParameters, String[])

Kompiliert eine Assembly aus dem in den angegebenen Dateien enthaltenen Quellcode mit den angegebenen Compilereinstellungen.

(Geerbt von CodeDomProvider)
CompileAssemblyFromSource(CompilerParameters, String[])

Kompiliert eine Assembly aus dem angegebenen Array von Zeichenfolgen mit Quellcode und unter Verwendung der angegebenen Compilereinstellungen.

(Geerbt von CodeDomProvider)
CreateCompiler()
Veraltet.
Veraltet.

Ruft eine Instanz des C#-Codecompilers ab.

CreateEscapedIdentifier(String)

Erstellt einen mit einem Escapezeichen versehenen Bezeichner für den angegebenen Wert.

(Geerbt von CodeDomProvider)
CreateGenerator()
Veraltet.
Veraltet.

Ruft eine Instanz des C#-Code-Generators ab.

CreateGenerator(String)

Erstellt beim Überschreiben in einer abgeleiteten Klasse einen neuen Codegenerator unter Verwendung des angegebenen Dateinamens für die Ausgabe.

(Geerbt von CodeDomProvider)
CreateGenerator(TextWriter)

Erstellt beim Überschreiben in einer abgeleiteten Klasse einen neuen Codegenerator unter Verwendung des angegebenen TextWriter für die Ausgabe.

(Geerbt von CodeDomProvider)
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.
Veraltet.

Erstellt beim Überschreiben in einer abgeleiteten Klasse einen neuen Codeparser.

(Geerbt von CodeDomProvider)
CreateValidIdentifier(String)

Erstellt einen gültigen Bezeichner für den angegebenen Wert.

(Geerbt von CodeDomProvider)
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.

(Geerbt von CodeDomProvider)
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.

(Geerbt von CodeDomProvider)
GenerateCodeFromMember(CodeTypeMember, TextWriter, CodeGeneratorOptions)

Generiert Code für den angegebenen Klassenmember unter Verwendung der angegebenen TextWriter- und Code-Generator-Optionen.

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.

(Geerbt von CodeDomProvider)
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.

(Geerbt von CodeDomProvider)
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.

(Geerbt von CodeDomProvider)
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.

(Geerbt von CodeDomProvider)
GetConverter(Type)

Ruft einen TypeConverter für den angegebenen Objekttyp ab.

GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
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.

(Geerbt von CodeDomProvider)
InitializeLifetimeService()
Veraltet.

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.

(Geerbt von MarshalByRefObject)
IsValidIdentifier(String)

Gibt einen Wert zurück, der angibt, ob der angegebene Wert ein gültiger Bezeichner für die aktuelle Sprache ist.

(Geerbt von CodeDomProvider)
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.

(Geerbt von CodeDomProvider)
Supports(GeneratorSupport)

Gibt einen Wert zurück, der angibt, ob die angegebene Unterstützung für die Codegenerierung verfügbar ist.

(Geerbt von CodeDomProvider)
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