CompilerParameters CompilerParameters CompilerParameters CompilerParameters Class

Définition

Représente les paramètres utilisés pour appeler un compilateur.Represents the parameters used to invoke a compiler.

public ref class CompilerParameters
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class CompilerParameters
type CompilerParameters = class
Public Class CompilerParameters
Héritage
CompilerParametersCompilerParametersCompilerParametersCompilerParameters
Dérivé
Attributs

Exemples

L’exemple suivant génère un graphique de source CodeDOM pour un programme Hello World simple.The following example builds a CodeDOM source graph for a simple Hello World program. La source est ensuite enregistrée dans un fichier, compilée dans un exécutable et exécutée.The source is then saved to a file, compiled into an executable, and run. La CompileCode méthode montre comment utiliser la CompilerParameters classe pour spécifier différents paramètres et options du compilateur.The CompileCode method illustrates how to use the CompilerParameters class to specify various compiler settings and options.

using namespace System;
using namespace System::CodeDom;
using namespace System::CodeDom::Compiler;
using namespace System::Collections;
using namespace System::ComponentModel;
using namespace System::IO;
using namespace System::Diagnostics;

// Build a Hello World program graph using System.CodeDom types.
static CodeCompileUnit^ BuildHelloWorldGraph()
{
   // Create a new CodeCompileUnit to contain the program graph.
   CodeCompileUnit^ compileUnit = gcnew CodeCompileUnit;
   
   // Declare a new namespace called Samples.
   CodeNamespace^ samples = gcnew 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( gcnew CodeNamespaceImport( "System" ) );
   
   // Declare a new type called Class1.
   CodeTypeDeclaration^ class1 = gcnew CodeTypeDeclaration( "Class1" );
   // Add the new type to the namespace's type collection.
   samples->Types->Add( class1 );
   
   // Declare a new code entry point method
   CodeEntryPointMethod^ start = gcnew CodeEntryPointMethod;
   
   // Create a type reference for the System::Console class.
   CodeTypeReferenceExpression^ csSystemConsoleType =
      gcnew CodeTypeReferenceExpression( "System.Console" );
   
   // Build a Console::WriteLine statement.
   CodeMethodInvokeExpression^ cs1 = gcnew CodeMethodInvokeExpression(
      csSystemConsoleType, "WriteLine",
      gcnew CodePrimitiveExpression( "Hello World!" ) );
   
   // Add the WriteLine call to the statement collection.
   start->Statements->Add( cs1 );
   
   // Build another Console::WriteLine statement.
   CodeMethodInvokeExpression^ cs2 = gcnew CodeMethodInvokeExpression(
      csSystemConsoleType, "WriteLine",
      gcnew 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.
   CodeMethodReferenceExpression^ csReadLine = gcnew CodeMethodReferenceExpression(
      csSystemConsoleType, "ReadLine" );
   CodeMethodInvokeExpression^ cs3 = gcnew CodeMethodInvokeExpression(
      csReadLine,gcnew array<CodeExpression^>(0) );
   
   // Add the ReadLine statement.
   start->Statements->Add( cs3 );
   
   // Add the code entry point method to the Members collection
   // of the type.
   class1->Members->Add( start );

   return compileUnit;
}

static String^ GenerateCode( CodeDomProvider^ provider, CodeCompileUnit^ compileunit )
{
   // Build the source file name with the language extension (vb, cs, js).
   String^ sourceFile = String::Empty;

      if ( provider->FileExtension->StartsWith( "." ) )
      {
         sourceFile = String::Concat( "HelloWorld", provider->FileExtension );
      }
      else
      {
         sourceFile = String::Concat( "HelloWorld.", provider->FileExtension );
      }

      // Create a TextWriter to a StreamWriter to an output file.
      IndentedTextWriter^ tw = gcnew IndentedTextWriter(
         gcnew StreamWriter( sourceFile,false ),"    " );
      // Generate source code using the code generator.
      provider->GenerateCodeFromCompileUnit( compileunit, tw, gcnew CodeGeneratorOptions );
      // Close the output file.
      tw->Close();
   return sourceFile;
}

static bool CompileCode( CodeDomProvider^ provider,
   String^ sourceFile,
   String^ exeFile )
{

   CompilerParameters^ cp = gcnew CompilerParameters;
   if ( !cp)  
   {
      return false;
   }

   // Generate an executable instead of 
   // a class library.
   cp->GenerateExecutable = true;
   
   // Set the assembly file name to generate.
   cp->OutputAssembly = exeFile;
   
   // Generate debug information.
   cp->IncludeDebugInformation = true;
   
   // Add an assembly reference.
   cp->ReferencedAssemblies->Add( "System.dll" );
   
   // Save the assembly as a physical file.
   cp->GenerateInMemory = false;
   
   // Set the level at which the compiler 
   // should start displaying warnings.
   cp->WarningLevel = 3;
   
   // Set whether to treat all warnings as errors.
   cp->TreatWarningsAsErrors = false;
   
   // Set compiler argument to optimize output.
   cp->CompilerOptions = "/optimize";
   
   // Set a temporary files collection.
   // The TempFileCollection stores the temporary files
   // generated during a build in the current directory,
   // and does not delete them after compilation.
   cp->TempFiles = gcnew TempFileCollection( ".",true );

   if ( provider->Supports( GeneratorSupport::EntryPointMethod ) )
   {
      // Specify the class that contains 
      // the main method of the executable.
      cp->MainClass = "Samples.Class1";
   }

   if ( Directory::Exists( "Resources" ) )
   {
      if ( provider->Supports( GeneratorSupport::Resources ) )
      {
         // Set the embedded resource file of the assembly.
         // This is useful for culture-neutral resources,
         // or default (fallback) resources.
         cp->EmbeddedResources->Add( "Resources\\Default.resources" );

         // Set the linked resource reference files of the assembly.
         // These resources are included in separate assembly files,
         // typically localized for a specific language and culture.
         cp->LinkedResources->Add( "Resources\\nb-no.resources" );
      }
   }

   // Invoke compilation.
   CompilerResults^ cr = provider->CompileAssemblyFromFile( cp, sourceFile );

   if ( cr->Errors->Count > 0 )
   {
      // Display compilation errors.
      Console::WriteLine( "Errors building {0} into {1}",
         sourceFile, cr->PathToAssembly );
      for each ( CompilerError^ ce in cr->Errors )
      {
         Console::WriteLine( "  {0}", ce->ToString() );
         Console::WriteLine();
      }
   }
   else
   {
      Console::WriteLine( "Source {0} built into {1} successfully.",
         sourceFile, cr->PathToAssembly );
   }

   // Return the results of compilation.
   if ( cr->Errors->Count > 0 )
   {
      return false;
   }
   else
   {
      return true;
   }
}

[STAThread]
void main()
{
   String^ exeName = "HelloWorld.exe";
   CodeDomProvider^ provider = nullptr;

   Console::WriteLine( "Enter the source language for Hello World (cs, vb, etc):" );
   String^ inputLang = Console::ReadLine();
   Console::WriteLine();

   if ( CodeDomProvider::IsDefinedLanguage( inputLang ) )
   {
      CodeCompileUnit^ helloWorld = BuildHelloWorldGraph();
      provider = CodeDomProvider::CreateProvider( inputLang );
      if ( helloWorld && provider )
      {
         String^ sourceFile = GenerateCode( provider, helloWorld );
         Console::WriteLine( "HelloWorld source code generated." );
         if ( CompileCode( provider, sourceFile, exeName ) )
         {
            Console::WriteLine( "Starting HelloWorld executable." );
            Process::Start( exeName );
         }
      }
   }

   if ( provider == nullptr )
   {
      Console::WriteLine( "There is no CodeDomProvider for the input language." );
   }
}
using System;
using System.Globalization;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.Collections;
using System.ComponentModel;
using System.IO;
using System.Diagnostics;

namespace CompilerParametersExample
{
    class CompileClass
    {
        // 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's 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 String GenerateCode(CodeDomProvider provider, 
                                          CodeCompileUnit compileunit)
        {
            // Build the source file name with the language
            // extension (vb, cs, js).
            String sourceFile;
            if (provider.FileExtension[0] == '.')
            {
                sourceFile = "HelloWorld" + provider.FileExtension;
            }
            else 
            {
                sourceFile = "HelloWorld." + provider.FileExtension;
            }

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

            return sourceFile;
        }
    
        public static bool CompileCode(CodeDomProvider provider, 
            String sourceFile, 
            String exeFile)
        {

            CompilerParameters cp = new CompilerParameters();

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

            // Set the assembly file name to generate.
            cp.OutputAssembly = exeFile;

            // Generate debug information.
            cp.IncludeDebugInformation = true;

            // Add an assembly reference.
            cp.ReferencedAssemblies.Add( "System.dll" );

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

            // Set the level at which the compiler 
            // should start displaying warnings.
            cp.WarningLevel = 3;

            // Set whether to treat all warnings as errors.
            cp.TreatWarningsAsErrors = false;
            
            // Set compiler argument to optimize output.
            cp.CompilerOptions = "/optimize";

            // Set a temporary files collection.
            // The TempFileCollection stores the temporary files
            // generated during a build in the current directory,
            // and does not delete them after compilation.
            cp.TempFiles = new TempFileCollection(".", true);

            if (provider.Supports(GeneratorSupport.EntryPointMethod))
            {
                // Specify the class that contains 
                // the main method of the executable.
                cp.MainClass = "Samples.Class1";
            }
  
            if (Directory.Exists("Resources"))
            {
                if (provider.Supports(GeneratorSupport.Resources))
                {
                    // Set the embedded resource file of the assembly.
                    // This is useful for culture-neutral resources,
                    // or default (fallback) resources.
                    cp.EmbeddedResources.Add("Resources\\Default.resources");

                    // Set the linked resource reference files of the assembly.
                    // These resources are included in separate assembly files,
                    // typically localized for a specific language and culture.
                    cp.LinkedResources.Add("Resources\\nb-no.resources");
                }
            }

            // Invoke compilation.
            CompilerResults cr = provider.CompileAssemblyFromFile(cp, sourceFile);

            if(cr.Errors.Count > 0)
            {
                // Display compilation errors.
                Console.WriteLine("Errors building {0} into {1}",  
                    sourceFile, cr.PathToAssembly);
                foreach(CompilerError ce in cr.Errors)
                {
                    Console.WriteLine("  {0}", ce.ToString());
                    Console.WriteLine();
                }
            }
            else
            {
                Console.WriteLine("Source {0} built into {1} successfully.",
                    sourceFile, cr.PathToAssembly);
                Console.WriteLine("{0} temporary files created during the compilation.",
                    cp.TempFiles.Count.ToString());

            }
          
            // Return the results of compilation.
            if (cr.Errors.Count > 0)
            {
                return false;
            }
            else 
            {
                return true;
            }
        }
 
        [STAThread]
        static void Main() 
        {
            CodeDomProvider provider = null;
            String exeName = "HelloWorld.exe";

            Console.WriteLine("Enter the source language for Hello World (cs, vb, etc):");
            String inputLang = Console.ReadLine();
            Console.WriteLine();

            if (CodeDomProvider.IsDefinedLanguage(inputLang))
            {
                provider = CodeDomProvider.CreateProvider(inputLang);
            }

            if (provider == null)
            {
                Console.WriteLine("There is no CodeDomProvider for the input language.");
            }
            else 
            {
                CodeCompileUnit helloWorld = BuildHelloWorldGraph();

                String sourceFile = GenerateCode(provider, helloWorld);

                Console.WriteLine("HelloWorld source code generated.");

                if (CompileCode(provider, sourceFile, exeName ))
                {
                    Console.WriteLine("Starting HelloWorld executable.");
                    Process.Start(exeName);            
                }
            }

        }
    }
}
Imports System.Globalization
Imports System.CodeDom
Imports System.CodeDom.Compiler
Imports System.Collections
Imports System.ComponentModel
Imports System.IO
Imports System.Diagnostics

Namespace CompilerParametersExample

    Class CompileClass

        ' Build a Hello World program graph using System.CodeDom types.
        Public Shared Function BuildHelloWorldGraph() As CodeCompileUnit

            ' Create a new CodeCompileUnit to contain the program graph.
            Dim compileUnit As New CodeCompileUnit()

            ' Declare a new namespace called Samples.
            Dim samples As 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.
            Dim Class1 As New CodeTypeDeclaration("Class1")

            ' Add the new type to the namespace's type collection.
            samples.Types.Add(class1)

            ' Declare a new code entry point method
            Dim start As New CodeEntryPointMethod()

            ' Create a type reference for the System.Console class.
            Dim csSystemConsoleType As New CodeTypeReferenceExpression( _
                "System.Console")

            ' Build a Console.WriteLine statement.
            Dim cs1 As 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.
            Dim cs2 As 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.
            Dim csReadLine As 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
        End Function


        Public Shared Function GenerateCode(ByVal provider As CodeDomProvider, _
        ByVal compileunit As CodeCompileUnit) As String

            ' Build the source file name with the language extension (vb, cs, js).
            Dim sourceFile As String
            If provider.FileExtension.StartsWith(".") Then
                sourceFile = "HelloWorld" + provider.FileExtension
            Else
                sourceFile = "HelloWorld." + provider.FileExtension
            End If

            ' Create a TextWriter to a StreamWriter to an output file.
            Dim tw As New IndentedTextWriter(New StreamWriter(sourceFile, False), "    ")

            ' Generate source code using the code provider.
            provider.GenerateCodeFromCompileUnit(compileunit, tw, _
                New CodeGeneratorOptions())

            ' Close the output file.
            tw.Close()

            Return sourceFile
        End Function 'GenerateCode


        Public Shared Function CompileCode(ByVal provider As CodeDomProvider, _
        ByVal sourceFile As String, ByVal exeFile As String) As Boolean

            Dim cp As New CompilerParameters()

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

            ' Set the assembly file name to generate.
            cp.OutputAssembly = exeFile

            ' Generate debug information.
            cp.IncludeDebugInformation = True

            ' Add an assembly reference.
            cp.ReferencedAssemblies.Add("System.dll")

            ' Save the assembly as a physical file.
            cp.GenerateInMemory = False

            ' Set the level at which the compiler 
            ' should start displaying warnings.
            cp.WarningLevel = 3

            ' Set whether to treat all warnings as errors.
            cp.TreatWarningsAsErrors = False

            ' Set compiler argument to optimize output.
            cp.CompilerOptions = "/optimize"

            ' Set a temporary files collection.
            ' The TempFileCollection stores the temporary files
            ' generated during a build in the current directory,
            ' and does not delete them after compilation.
            cp.TempFiles = New TempFileCollection(".", True)

            If provider.Supports(GeneratorSupport.EntryPointMethod) Then
                ' Specify the class that contains
                ' the main method of the executable.
                cp.MainClass = "Samples.Class1"
            End If


            If Directory.Exists("Resources") Then
                If provider.Supports(GeneratorSupport.Resources) Then
                    ' Set the embedded resource file of the assembly.
                    ' This is useful for culture-neutral resources,
                    ' or default (fallback) resources.
                    cp.EmbeddedResources.Add("Resources\Default.resources")

                    ' Set the linked resource reference files of the assembly.
                    ' These resources are included in separate assembly files,
                    ' typically localized for a specific language and culture.
                    cp.LinkedResources.Add("Resources\nb-no.resources")
                End If
            End If

            ' Invoke compilation.
            Dim cr As CompilerResults = _
                provider.CompileAssemblyFromFile(cp, sourceFile)

            If cr.Errors.Count > 0 Then
                ' Display compilation errors.
                Console.WriteLine("Errors building {0} into {1}", _
                    sourceFile, cr.PathToAssembly)
                Dim ce As CompilerError
                For Each ce In cr.Errors
                    Console.WriteLine("  {0}", ce.ToString())
                    Console.WriteLine()
                Next ce
            Else
                Console.WriteLine("Source {0} built into {1} successfully.", _
                    sourceFile, cr.PathToAssembly)
                Console.WriteLine("{0} temporary files created during the compilation.", _
                        cp.TempFiles.Count.ToString())
            End If

            ' Return the results of compilation.
            If cr.Errors.Count > 0 Then
                Return False
            Else
                Return True
            End If
        End Function 'CompileCode

        <STAThread()> _
        Shared Sub Main()
            Dim exeName As String = "HelloWorld.exe"
            Dim provider As CodeDomProvider = Nothing

            Console.WriteLine("Enter the source language for Hello World (cs, vb, etc):")
            Dim inputLang As String = Console.ReadLine()
            Console.WriteLine()

            If CodeDomProvider.IsDefinedLanguage(inputLang) Then
                Dim helloWorld As CodeCompileUnit = BuildHelloWorldGraph()
                provider = CodeDomProvider.CreateProvider(inputLang)

                Dim sourceFile As String
                sourceFile = GenerateCode(provider, helloWorld)

                Console.WriteLine("HelloWorld source code generated.")

                If CompileCode(provider, sourceFile, exeName) Then
                    Console.WriteLine("Starting HelloWorld executable.")
                    Process.Start(exeName)
                End If
            End If

            If provider Is Nothing Then
                Console.WriteLine("There is no CodeDomProvider for the input language.")
            End If
        End Sub 'Main 

    End Class 'CompileClass
End Namespace

Remarques

Un CompilerParameters objet représente les paramètres et les options d' ICodeCompiler une interface.A CompilerParameters object represents the settings and options for an ICodeCompiler interface.

Si vous compilez un programme exécutable, vous devez affecter à GenerateExecutable truela propriété la valeur.If you are compiling an executable program, you must set the GenerateExecutable property to true. Quand a GenerateExecutable la falsevaleur, le compilateur génère une bibliothèque de classes.When the GenerateExecutable is set to false, the compiler will generate a class library. Par défaut, un nouveau CompilerParameters est initialisé avec sa GenerateExecutable propriété définie sur false.By default, a new CompilerParameters is initialized with its GenerateExecutable property set to false. Si vous compilez un exécutable à partir d’un graphique CodeDOM, un CodeEntryPointMethod doit être défini dans le graphique.If you are compiling an executable from a CodeDOM graph, a CodeEntryPointMethod must be defined in the graph. S’il y a plusieurs points d’entrée de code, vous pouvez indiquer la classe qui définit le point d’entrée à utiliser en affectant à la MainClass propriété le nom de la classe.If there are multiple code entry points, you can indicate the class that defines the entry point to use by setting the name of the class to the MainClass property.

Vous pouvez spécifier un nom de fichier pour l’assembly de OutputAssembly sortie dans la propriété.You can specify a file name for the output assembly in the OutputAssembly property. Sinon, un nom de fichier de sortie par défaut est utilisé.Otherwise, a default output file name will be used. Pour inclure des informations de débogage dans un assembly IncludeDebugInformation généré, trueaffectez la valeur à la propriété.To include debug information in a generated assembly, set the IncludeDebugInformation property to true. Si votre projet fait référence à des assemblys, vous devez spécifier les noms d’assembly StringCollection en tant qu' ReferencedAssemblies éléments dans un CompilerParameters objet défini sur la propriété du utilisé lors de l’appel de la compilation.If your project references any assemblies, you must specify the assembly names as items in a StringCollection set to the ReferencedAssemblies property of the CompilerParameters used when invoking compilation.

Vous pouvez compiler un assembly écrit dans la mémoire plutôt que sur le disque en GenerateInMemory affectant trueà la propriété la valeur.You can compile an assembly that is written to memory rather than disk by setting the GenerateInMemory property to true. Quand un assembly est généré en mémoire, votre code peut obtenir une référence à l’assembly généré à partir de la propriétés CompiledAssembly d’un CompilerResults.When an assembly is generated in memory, your code can obtain a reference to the generated assembly from the CompiledAssembly property of a CompilerResults. Si un assembly est écrit sur le disque, vous pouvez obtenir le chemin d’accès à l' PathToAssembly assembly généré CompilerResultsà partir de la propriété d’un.If an assembly is written to disk, you can obtain the path to the generated assembly from the PathToAssembly property of a CompilerResults.

Pour spécifier un niveau d’avertissement auquel il faut arrêter la compilation, affectez à la propriété WarningLevel un entier qui représente le niveau d’avertissement.To specify a warning level at which to halt compilation, set the WarningLevel property to an integer that represents the warning level at which to halt compilation. Vous pouvez également configurer le compilateur pour arrêter la compilation si des avertissements sont rencontrés en TreatWarningsAsErrors affectant trueà la propriété la valeur.You can also configure the compiler to halt compilation if warnings are encountered by setting the TreatWarningsAsErrors property to true.

Pour spécifier une chaîne d’arguments de ligne de commande personnalisée à utiliser lors de l’appel du processus de compilation, définissez la chaîne dans la propriété CompilerOptions.To specify a custom command-line arguments string to use when invoking the compilation process, set the string in the CompilerOptions property. Si un jeton de sécurité Win32 est nécessaire pour appeler le processus de compilation, spécifiez-le dans la propriété UserToken.If a Win32 security token is required to invoke the compiler process, specify the token in the UserToken property. Pour inclure .NET Framework fichiers de ressources dans l’assembly compilé, ajoutez les noms des fichiers de ressources EmbeddedResources à la propriété.To include .NET Framework resource files in the compiled assembly, add the names of the resource files to the EmbeddedResources property. Pour référencer .NET Framework ressources dans un autre assembly, ajoutez les noms des fichiers de LinkedResources ressources à la propriété.To reference .NET Framework resources in another assembly, add the names of the resource files to the LinkedResources property. Pour inclure un fichier de ressources Win32 dans l’assembly compilé, spécifiez le nom du fichier de ressources Win32Resource Win32 dans la propriété.To include a Win32 resource file in the compiled assembly, specify the name of the Win32 resource file in the Win32Resource property.

Notes

Cette classe contient une demande de liaison et une demande d’héritage au niveau de la classe qui s’applique à tous les membres.This class contains a link demand and an inheritance demand at the class level that applies to all members. Une SecurityException exception est levée lorsque l’appelant immédiat ou la classe dérivée ne dispose pas d’une autorisation de confiance totale.A SecurityException is thrown when either the immediate caller or the derived class does not have full-trust permission. Pour plus d’informations sur les demandes de sécurité, consultez demandes de liaison et demandes d’héritage.For details about security demands, see Link Demands and Inheritance Demands.

Constructeurs

CompilerParameters() CompilerParameters() CompilerParameters() CompilerParameters()

Initialise une nouvelle instance de la classe CompilerParameters.Initializes a new instance of the CompilerParameters class.

CompilerParameters(String[]) CompilerParameters(String[]) CompilerParameters(String[]) CompilerParameters(String[])

Initialise une nouvelle instance de la classe CompilerParameters avec les noms d'assemblys spécifiés.Initializes a new instance of the CompilerParameters class using the specified assembly names.

CompilerParameters(String[], String) CompilerParameters(String[], String) CompilerParameters(String[], String) CompilerParameters(String[], String)

Initialise une nouvelle instance de la classe CompilerParameters avec les noms d'assemblys et le nom du fichier de sortie spécifiés.Initializes a new instance of the CompilerParameters class using the specified assembly names and output file name.

CompilerParameters(String[], String, Boolean) CompilerParameters(String[], String, Boolean) CompilerParameters(String[], String, Boolean) CompilerParameters(String[], String, Boolean)

Initialise une nouvelle instance de la classe CompilerParameters avec les noms d'assemblys spécifiés, le nom de sortie spécifié et une valeur indiquant s'il faut inclure les informations de débogage.Initializes a new instance of the CompilerParameters class using the specified assembly names, output name, and a value indicating whether to include debug information.

Propriétés

CompilerOptions CompilerOptions CompilerOptions CompilerOptions

Obtient ou définit les arguments de ligne de commande facultatifs à utiliser lorsque le compilateur est appelé.Gets or sets optional command-line arguments to use when invoking the compiler.

CoreAssemblyFileName CoreAssemblyFileName CoreAssemblyFileName CoreAssemblyFileName

Obtient ou définit le nom de l'assembly principal ou standard qui contient des types de base tels que Object, String ou Int32.Gets or sets the name of the core or standard assembly that contains basic types such as Object, String, or Int32.

EmbeddedResources EmbeddedResources EmbeddedResources EmbeddedResources

Obtient les fichiers de ressources .NET Framework à inclure lors de la compilation de la sortie d'assembly.Gets the .NET Framework resource files to include when compiling the assembly output.

Evidence Evidence Evidence Evidence

Spécifie un objet de preuve qui représente les autorisations accordées par la stratégie de sécurité à l'assembly compilé.Specifies an evidence object that represents the security policy permissions to grant the compiled assembly.

GenerateExecutable GenerateExecutable GenerateExecutable GenerateExecutable

Obtient ou définit une valeur indiquant si un exécutable doit être généré.Gets or sets a value indicating whether to generate an executable.

GenerateInMemory GenerateInMemory GenerateInMemory GenerateInMemory

Obtient ou définit une valeur indiquant si le résultat doit être généré dans la mémoire.Gets or sets a value indicating whether to generate the output in memory.

IncludeDebugInformation IncludeDebugInformation IncludeDebugInformation IncludeDebugInformation

Obtient ou définit une valeur indiquant si les informations de débogage doivent être incluses dans l'exécutable compilé.Gets or sets a value indicating whether to include debug information in the compiled executable.

LinkedResources LinkedResources LinkedResources LinkedResources

Obtient les fichiers de ressources .NET Framework qui sont référencés dans la source actuelle.Gets the .NET Framework resource files that are referenced in the current source.

MainClass MainClass MainClass MainClass

Obtient ou définit le nom de la classe principale.Gets or sets the name of the main class.

OutputAssembly OutputAssembly OutputAssembly OutputAssembly

Obtient ou définit le nom de l'assembly de sortie.Gets or sets the name of the output assembly.

ReferencedAssemblies ReferencedAssemblies ReferencedAssemblies ReferencedAssemblies

Obtient les assemblys référencés par le projet actuel.Gets the assemblies referenced by the current project.

TempFiles TempFiles TempFiles TempFiles

Obtient ou définit la collection qui contient les fichiers temporaires.Gets or sets the collection that contains the temporary files.

TreatWarningsAsErrors TreatWarningsAsErrors TreatWarningsAsErrors TreatWarningsAsErrors

Obtient ou définit une valeur indiquant s'il faut traiter les avertissements comme des erreurs.Gets or sets a value indicating whether to treat warnings as errors.

UserToken UserToken UserToken UserToken

Obtient ou définit le jeton utilisateur à employer à la création du processus de compilation.Gets or sets the user token to use when creating the compiler process.

WarningLevel WarningLevel WarningLevel WarningLevel

Obtient ou définit le niveau d'avertissement auquel le compilateur abandonne la compilation.Gets or sets the warning level at which the compiler aborts compilation.

Win32Resource Win32Resource Win32Resource Win32Resource

Obtient ou définit le nom d'un fichier de ressources Win32 à lier à l'assembly compilé.Gets or sets the file name of a Win32 resource file to link into the compiled assembly.

Méthodes

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)

Sécurité

LinkDemand
pour une confiance totale pour l’appelant immédiat.for full trust for the immediate caller. Cette classe ne peut pas être utilisée par du code d'un niveau de confiance partiel.This class cannot be used by partially trusted code.

InheritanceDemand
pour une confiance totale pour les héritiers.for full trust for inheritors. Cette classe ne peut pas être héritée par du code de confiance partielle.This class cannot be inherited by partially trusted code.

S’applique à