CSharpCodeProvider Classe

Definizione

Fornisce l'accesso alle istanze del generatore e del compilatore di codice C#.

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
Ereditarietà

Esempio

Nell'esempio seguente viene usato il provider di codice C# o Visual Basic per compilare un file di origine. Nell'esempio viene controllata l'estensione del file di input e viene utilizzata la classe corrispondente CSharpCodeProvider o VBCodeProvider per la compilazione. Il file di input viene compilato in un file eseguibile e tutti gli errori di compilazione vengono visualizzati nella console.

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

Commenti

Questa classe fornisce metodi che possono essere usati per recuperare istanze di C# ICodeGenerator e ICodeCompiler implementazioni.

Nota

Questa classe contiene una richiesta di collegamento e una richiesta di ereditarietà a livello di classe che si applica a tutti i membri. Viene SecurityException generata un'eccezione quando il chiamante immediato o la classe derivata non dispone dell'autorizzazione di attendibilità totale.

Costruttori

CSharpCodeProvider()

Inizializza una nuova istanza della classe CSharpCodeProvider.

CSharpCodeProvider(IDictionary<String,String>)

Inizializza una nuova istanza della classe CSharpCodeProvider tramite le opzioni del provider specificate.

Proprietà

CanRaiseEvents

Ottiene un valore che indica se il componente può generare un evento.

(Ereditato da Component)
Container

Ottiene l'oggetto IContainer che contiene Component.

(Ereditato da Component)
DesignMode

Ottiene un valore che indica se il Component si trova in modalità progettazione.

(Ereditato da Component)
Events

Ottiene l'elenco dei gestori eventi allegati a questo Component.

(Ereditato da Component)
FileExtension

Ottiene l'estensione di file da usare per la creazione di file di codice sorgente.

LanguageOptions

Ottiene un identificatore delle funzionalità del linguaggio.

(Ereditato da CodeDomProvider)
Site

Ottiene o imposta l'oggetto ISite di Component.

(Ereditato da Component)

Metodi

CompileAssemblyFromDom(CompilerParameters, CodeCompileUnit[])

Compila un assembly in base alle strutture ad albero System.CodeDom contenute nella matrice di oggetti CodeCompileUnit specificata utilizzando le impostazioni del compilatore specificato.

(Ereditato da CodeDomProvider)
CompileAssemblyFromFile(CompilerParameters, String[])

Compila un assembly dal codice sorgente contenuto nei file specificati, utilizzando le impostazioni del compilatore specificato.

(Ereditato da CodeDomProvider)
CompileAssemblyFromSource(CompilerParameters, String[])

Compila un assembly dalla matrice di stringhe specificata contenente il codice sorgente utilizzando le impostazioni del compilatore specificato.

(Ereditato da CodeDomProvider)
CreateCompiler()
Obsoleti.
Obsoleti.

Ottiene un'istanza del compilatore di codice C#.

CreateEscapedIdentifier(String)

Crea un identificatore di escape per il valore specificato.

(Ereditato da CodeDomProvider)
CreateGenerator()
Obsoleti.
Obsoleti.

Ottiene un'istanza del generatore di codice C#.

CreateGenerator(String)

Quando è sottoposto a override in una classe derivata, crea un nuovo generatore di codice utilizzando per l'output il nome file specificato.

(Ereditato da CodeDomProvider)
CreateGenerator(TextWriter)

Quando è sottoposto a override in una classe derivata, crea un nuovo generatore di codice utilizzando per l'output l'oggetto TextWriter specificato.

(Ereditato da CodeDomProvider)
CreateObjRef(Type)

Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto.

(Ereditato da MarshalByRefObject)
CreateParser()
Obsoleti.
Obsoleti.

Quando è sottoposto a override in una classe derivata, crea un nuovo parser di codice.

(Ereditato da CodeDomProvider)
CreateValidIdentifier(String)

Crea un identificatore valido per il valore specificato.

(Ereditato da CodeDomProvider)
Dispose()

Rilascia tutte le risorse usate da Component.

(Ereditato da Component)
Dispose(Boolean)

Rilascia le risorse non gestite usate da Component e, facoltativamente, le risorse gestite.

(Ereditato da Component)
Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GenerateCodeFromCompileUnit(CodeCompileUnit, TextWriter, CodeGeneratorOptions)

Genera il codice per l'unità di compilazione CodeDOM (Code Document Object Model) specificata e lo invia al writer di testo indicato utilizzando le opzioni selezionate.

(Ereditato da CodeDomProvider)
GenerateCodeFromExpression(CodeExpression, TextWriter, CodeGeneratorOptions)

Genera il codice per l'espressione CodeDOM (Code Document Object Model) specificata e lo invia al writer di testo indicato utilizzando le opzioni selezionate.

(Ereditato da CodeDomProvider)
GenerateCodeFromMember(CodeTypeMember, TextWriter, CodeGeneratorOptions)

Genera codice per il membro della classe specificato usando le opzioni del writer di testo e del generatore di codice specificate.

GenerateCodeFromMember(CodeTypeMember, TextWriter, CodeGeneratorOptions)

Genera il codice per la dichiarazione di membro CodeDOM (Code Document Object Model) specificata e lo invia al writer di testo indicato utilizzando le opzioni selezionate.

(Ereditato da CodeDomProvider)
GenerateCodeFromNamespace(CodeNamespace, TextWriter, CodeGeneratorOptions)

Genera il codice per lo spazio dei nomi CodeDOM (Code Document Object Model) specificato e lo invia al writer di testo indicato utilizzando le opzioni selezionate.

(Ereditato da CodeDomProvider)
GenerateCodeFromStatement(CodeStatement, TextWriter, CodeGeneratorOptions)

Genera il codice per l'istruzione CodeDOM (Code Document Object Model) specificata e lo invia al writer di testo indicato utilizzando le opzioni selezionate.

(Ereditato da CodeDomProvider)
GenerateCodeFromType(CodeTypeDeclaration, TextWriter, CodeGeneratorOptions)

Genera il codice per la dichiarazione di tipo CodeDOM (Code Document Object Model) specificata e lo invia al writer di testo indicato utilizzando le opzioni selezionate.

(Ereditato da CodeDomProvider)
GetConverter(Type)

Ottiene un oggetto TypeConverter per il tipo di oggetto specificato.

GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetLifetimeService()
Obsoleti.

Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.

(Ereditato da MarshalByRefObject)
GetService(Type)

Consente di restituire un oggetto che rappresenta un servizio fornito da Component o dal relativo Container.

(Ereditato da Component)
GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
GetTypeOutput(CodeTypeReference)

Ottiene il tipo indicato dall'oggetto CodeTypeReference specificato.

(Ereditato da CodeDomProvider)
InitializeLifetimeService()
Obsoleti.

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.

(Ereditato da MarshalByRefObject)
IsValidIdentifier(String)

Restituisce un valore che indica se il valore specificato rappresenta un identificatore valido per il linguaggio corrente.

(Ereditato da CodeDomProvider)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
MemberwiseClone(Boolean)

Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.

(Ereditato da MarshalByRefObject)
Parse(TextReader)

Compila il codice letto dal flusso di testo specificato in un oggetto CodeCompileUnit.

(Ereditato da CodeDomProvider)
Supports(GeneratorSupport)

Restituisce un valore che indica se viene fornito il supporto per la generazione di codice specificato.

(Ereditato da CodeDomProvider)
ToString()

Restituisce un oggetto String che contiene il nome dell'eventuale oggetto Component. Questo metodo non deve essere sottoposto a override.

(Ereditato da Component)

Eventi

Disposed

Si verifica quando il componente viene eliminato da una chiamata al metodo Dispose().

(Ereditato da Component)

Si applica a

Vedi anche