VBCodeProvider Classe

Définition

Espace de noms:

Microsoft.VisualBasic

Assembly:

System.CodeDom.dll

Paquet:

System.CodeDom v8.0.0

Source:

VBCodeProvider.cs

Donne accès aux instances du générateur de code et du compilateur de code Visual Basic.

public ref class VBCodeProvider : System::CodeDom::Compiler::CodeDomProvider

public class VBCodeProvider : System.CodeDom.Compiler.CodeDomProvider

type VBCodeProvider = class
    inherit CodeDomProvider

Public Class VBCodeProvider
Inherits CodeDomProvider

Héritage

Object

MarshalByRefObject

Component

CodeDomProvider

VBCodeProvider

Exemples

L’exemple suivant utilise le fournisseur de code C# ou Visual Basic pour compiler un fichier source. L’exemple vérifie l’extension de fichier d’entrée et utilise le correspondant CSharpCodeProvider ou VBCodeProvider pour la compilation. Le fichier d’entrée est compilé dans un fichier exécutable et toutes les erreurs de compilation sont affichées dans la console.

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;
}

       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

Remarques

Cette classe fournit des méthodes qui peuvent être utilisées pour récupérer des instances de Visual Basic ICodeGenerator et ICodeCompiler des implémentations.

Notes

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

Constructeurs

VBCodeProvider()	Initialise une nouvelle instance de la classe VBCodeProvider.
VBCodeProvider(IDictionary<String,String>)	Initialise une nouvelle instance de la classe VBCodeProvider en utilisant les options de fournisseur spécifiées.

Propriétés

CanRaiseEvents	Obtient une valeur qui indique si le composant peut déclencher un événement. (Hérité de Component)
Container	Obtient le IContainer qui contient la Component. (Hérité de Component)
DesignMode	Obtient une valeur qui indique si Component est actuellement en mode design. (Hérité de Component)
Events	Obtient la liste des gestionnaires d'événements attachés à ce Component. (Hérité de Component)
FileExtension	Obtient l'extension de nom de fichier à utiliser pendant la création de fichiers de code source.
LanguageOptions	Obtient un identificateur de fonctionnalités de langage.
Site	Obtient ou définit le ISite de Component. (Hérité de Component)

Méthodes

CompileAssemblyFromDom(CompilerParameters, CodeCompileUnit[])	Compile un assembly basé sur les arborescences System.CodeDom contenues dans le tableau d'objets CodeCompileUnit spécifié, à l'aide des paramètres du compilateur spécifiés. (Hérité de CodeDomProvider)
CompileAssemblyFromFile(CompilerParameters, String[])	Compile un assembly à partir du code source contenu dans les fichiers spécifiés, à l'aide des paramètres du compilateur spécifiés. (Hérité de CodeDomProvider)
CompileAssemblyFromSource(CompilerParameters, String[])	Compile un assembly à partir du tableau de chaînes spécifié contenant le code source, à l'aide des paramètres du compilateur spécifiés. (Hérité de CodeDomProvider)
CreateCompiler()	Obsolète. Obtient une instance du compilateur de code Visual Basic.
CreateEscapedIdentifier(String)	Crée un identificateur avec séquence d'échappement pour la valeur spécifiée. (Hérité de CodeDomProvider)
CreateGenerator()	Obsolète. Obtient une instance du générateur de code Visual Basic.
CreateGenerator(String)	En cas de substitution dans une classe dérivée, crée un nouveau générateur de code à l'aide du nom de fichier spécifié pour la sortie. (Hérité de CodeDomProvider)
CreateGenerator(TextWriter)	En cas de substitution dans une classe dérivée, crée un nouveau générateur de code à l'aide du TextWriter spécifié pour la sortie. (Hérité de CodeDomProvider)
CreateObjRef(Type)	Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant. (Hérité de MarshalByRefObject)
CreateParser()	Obsolète. En cas de substitution dans une classe dérivée, crée un nouvel analyseur de code. (Hérité de CodeDomProvider)
CreateValidIdentifier(String)	Crée un identificateur valide pour la valeur spécifiée. (Hérité de CodeDomProvider)
Dispose()	Libère toutes les ressources utilisées par Component. (Hérité de Component)
Dispose(Boolean)	Libère les ressources non managées utilisées par Component et libère éventuellement les ressources managées. (Hérité de Component)
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GenerateCodeFromCompileUnit(CodeCompileUnit, TextWriter, CodeGeneratorOptions)	Génère du code pour l'unité de compilation CodeDOM (Code Document Object Model) spécifiée et l'envoie au writer de texte spécifié, à l'aide des options définies. (Hérité de CodeDomProvider)
GenerateCodeFromExpression(CodeExpression, TextWriter, CodeGeneratorOptions)	Génère du code pour l'expression CodeDOM (Code Document Object Model) spécifiée et l'envoie au writer de texte spécifié, à l'aide des options définies. (Hérité de CodeDomProvider)
GenerateCodeFromMember(CodeTypeMember, TextWriter, CodeGeneratorOptions)	Génère du code pour le membre de classe spécifié en utilisant les options spécifiées du TextWriter et du générateur de code.
GenerateCodeFromNamespace(CodeNamespace, TextWriter, CodeGeneratorOptions)	Génère du code pour l'espace de noms CodeDOM (Code Document Object Model) spécifié et l'envoie au writer de texte spécifié, à l'aide des options définies. (Hérité de CodeDomProvider)
GenerateCodeFromStatement(CodeStatement, TextWriter, CodeGeneratorOptions)	Génère du code pour l'instruction CodeDOM (Code Document Object Model) spécifiée et l'envoie au writer de texte spécifié, à l'aide des options définies. (Hérité de CodeDomProvider)
GenerateCodeFromType(CodeTypeDeclaration, TextWriter, CodeGeneratorOptions)	Génère du code pour la déclaration de type CodeDOM (Code Document Object Model) spécifiée et l'envoie au writer de texte spécifié, à l'aide des options définies. (Hérité de CodeDomProvider)
GetConverter(Type)	Obtient un TypeConverter pour le type d'objet spécifié.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetLifetimeService()	Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
GetService(Type)	Retourne un objet qui représente un service fourni par Component ou par son Container. (Hérité de Component)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
GetTypeOutput(CodeTypeReference)	Obtient le type indiqué par le CodeTypeReference spécifié. (Hérité de CodeDomProvider)
InitializeLifetimeService()	Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
IsValidIdentifier(String)	Retourne une valeur indiquant si la valeur spécifiée est un identificateur valide pour le langage actuel. (Hérité de CodeDomProvider)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l'objet MarshalByRefObject actuel. (Hérité de MarshalByRefObject)
Parse(TextReader)	Compile le code lu à partir du flux de texte spécifié dans CodeCompileUnit. (Hérité de CodeDomProvider)
Supports(GeneratorSupport)	Retourne une valeur indiquant si la prise en charge de la génération de code spécifiée est fournie. (Hérité de CodeDomProvider)
ToString()	Retourne un String contenant le nom du Component, s’il en existe un. Cette méthode ne doit pas être remplacée. (Hérité de Component)

Événements

Disposed

Se produit lorsque le composant est supprimé par un appel à la méthode Dispose(). (Hérité de Component)

Voir aussi

• ICodeGenerator
• ICodeCompiler
• System.CodeDom
• System.CodeDom.Compiler