CompilerParameters (Clase)

Una clase CompilerParameters representa las opciones y valores de configuración para una interfaz ICodeCompiler.

Si se compila un programa ejecutable, se debe establecer la propiedad GenerateExecutable en true. Si la propiedad GenerateExecutable se establece en false, el compilador genera una biblioteca de clases. De manera predeterminada, se inicializa una nueva clase CompilerParameters con su propiedad GenerateExecutable establecida en false. Si compila un ejecutable a partir de un gráfico CodeDOM, debe definir CodeEntryPointMethod en el gráfico. Si hay varios puntos de entrada de código, se puede indicar la clase que define el punto de entrada que se va a utilizar. Para ello, establezca el nombre de la clase en la propiedad MainClass.

Se puede especificar un nombre de archivo para el ensamblado resultante en la propiedad OutputAssembly. En caso contrario, se utilizará un nombre de archivo de resultados predeterminado. Para incluir información de depuración en un ensamblado generado, establezca la propiedad IncludeDebugInformation en true. Si el proyecto hace referencia a ensamblados, se deben especificar los nombres de los ensamblados como elementos de una clase StringCollection establecidos en la propiedad ReferencedAssemblies de la clase CompilerParameters utilizada al invocar a la compilación.

Se puede compilar un ensamblado que se escribe en memoria en lugar de en disco estableciendo la propiedad GenerateInMemory en true. Si se genera un ensamblado en memoria, el código puede obtener una referencia al ensamblado generado desde la propiedad CompiledAssembly de una clase CompilerResults. Si se escribe un ensamblado en disco, se puede obtener la ruta de acceso al ensamblado generado de la propiedad PathToAssembly de una clase CompilerResults.

Para especificar un nivel de advertencia en el que se detendrá la compilación, establezca la propiedad WarningLevel en un entero que represente el nivel de advertencia en el que se detendrá la compilación. También se puede configurar el compilador de modo que detenga la compilación si se producen advertencias al establecer la propiedad TreatWarningsAsErrors en true.

Para especificar una cadena de argumentos de línea de comandos personalizados que se utilizarán al invocar el proceso de compilación, establezca la cadena en la propiedad CompilerOptions. Si se requiere un símbolo de seguridad Win32 para invocar al proceso de compilación, especifique el símbolo en la propiedad UserToken. Para incluir archivos de recursos de .NET Framework en el ensamblado compilado, agregue los nombres de los archivos de recursos a la propiedad EmbeddedResources. Para hacer referencia a recursos de .NET Framework en otro ensamblado, agregue los nombres de los archivos de recursos a la propiedad LinkedResources. Para incluir archivos de recursos de Win32 en el ensamblado compilado, especifique el nombre del archivo de recursos de Win32 en la propiedad Win32Resource.

Nota
Esta clase contiene una petición de vínculo y una petición de herencia en el nivel de clase que se aplica a todos los miembros. Se produce una excepción SecurityException si el llamador inmediato o la clase derivada no disponen de permisos de plena confianza. Para obtener más información sobre las peticiones de seguridad, vea Peticiones de vínculos y Peticiones de herencia.

En el ejemplo siguiente se muestra el uso de la clase CompilerParameters para especificar distintas opciones y valores de configuración del compilador.

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

• SecurityPermission  para llamar a los miembros de CompilerParameters. Valor de la petición: LinkDemand; Conjuntos de permisos con nombre: FullTrust.
• SecurityPermission  para derivar de la clase CompilerParameters. Valor de la petición: InheritanceDemand; Conjuntos de permisos con nombre: FullTrust.

Windows 98, Windows 2000 SP4, Windows Millennium, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter Edition

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

.NET Framework