Export (0) Print
Expand All

CompilerParameters Class

Represents the parameters used to invoke a compiler.

Namespace:  System.CodeDom.Compiler
Assembly:  System (in System.dll)

<SerializableAttribute> _
<PermissionSetAttribute(SecurityAction.LinkDemand, Name := "FullTrust")> _
<PermissionSetAttribute(SecurityAction.InheritanceDemand, Name := "FullTrust")> _
Public Class CompilerParameters

The CompilerParameters type exposes the following members.

Public methodCompilerParametersInitializes a new instance of the CompilerParameters class.
Public methodCompilerParameters(String())Initializes a new instance of the CompilerParameters class using the specified assembly names.
Public methodCompilerParameters(String(), String)Initializes a new instance of the CompilerParameters class using the specified assembly names and output file name.
Public methodCompilerParameters(String(), String, Boolean)Initializes a new instance of the CompilerParameters class using the specified assembly names, output name, and a value indicating whether to include debug information.

Public propertyCompilerOptionsGets or sets optional command-line arguments to use when invoking the compiler.
Public propertyCoreAssemblyFileNameGets or sets the name of the core or standard assembly that contains basic types such as Object, String, or Int32.
Public propertyEmbeddedResourcesGets the .NET Framework resource files to include when compiling the assembly output.
Public propertyEvidence Obsolete. Specifies an evidence object that represents the security policy permissions to grant the compiled assembly.
Public propertyGenerateExecutableGets or sets a value indicating whether to generate an executable.
Public propertyGenerateInMemoryGets or sets a value indicating whether to generate the output in memory.
Public propertyIncludeDebugInformationGets or sets a value indicating whether to include debug information in the compiled executable.
Public propertyLinkedResourcesGets the .NET Framework resource files that are referenced in the current source.
Public propertyMainClassGets or sets the name of the main class.
Public propertyOutputAssemblyGets or sets the name of the output assembly.
Public propertyReferencedAssembliesGets the assemblies referenced by the current project.
Public propertyTempFilesGets or sets the collection that contains the temporary files.
Public propertyTreatWarningsAsErrorsGets or sets a value indicating whether to treat warnings as errors.
Public propertyUserTokenGets or sets the user token to use when creating the compiler process.
Public propertyWarningLevelGets or sets the warning level at which the compiler aborts compilation.
Public propertyWin32ResourceGets or sets the file name of a Win32 resource file to link into the compiled assembly.

Public methodEquals(Object)Determines whether the specified object is equal to the current object. (Inherited from Object.)
Protected methodFinalizeAllows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection. (Inherited from Object.)
Public methodGetHashCodeServes as the default hash function. (Inherited from Object.)
Public methodGetTypeGets the Type of the current instance. (Inherited from Object.)
Protected methodMemberwiseCloneCreates a shallow copy of the current Object. (Inherited from Object.)
Public methodToStringReturns a string that represents the current object. (Inherited from Object.)

A CompilerParameters object represents the settings and options for an ICodeCompiler interface.

If you are compiling an executable program, you must set the GenerateExecutable property to true. When the GenerateExecutable is set to false, the compiler will generate a class library. By default, a new CompilerParameters is initialized with its GenerateExecutable property set to false. If you are compiling an executable from a CodeDOM graph, a CodeEntryPointMethod must be defined in the graph. 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.

You can specify a file name for the output assembly in the OutputAssembly property. Otherwise, a default output file name will be used. To include debug information in a generated assembly, set the IncludeDebugInformation property to true. 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.

You can compile an assembly that is written to memory rather than disk by setting the GenerateInMemory property to true. When an assembly is generated in memory, your code can obtain a reference to the generated assembly from the CompiledAssembly property of a CompilerResults. If an assembly is written to disk, you can obtain the path to the generated assembly from the PathToAssembly property of a CompilerResults.

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. You can also configure the compiler to halt compilation if warnings are encountered by setting the TreatWarningsAsErrors property to true.

To specify a custom command-line arguments string to use when invoking the compilation process, set the string in the CompilerOptions property. If a Win32 security token is required to invoke the compiler process, specify the token in the UserToken property. To include .NET Framework resource files in the compiled assembly, add the names of the resource files to the EmbeddedResources property. To reference .NET Framework resources in another assembly, add the names of the resource files to the LinkedResources property. To include a Win32 resource file in the compiled assembly, specify the name of the Win32 resource file in the Win32Resource property.


This class contains a link demand and an inheritance demand at the class level that applies to all members. A SecurityException is thrown when either the immediate caller or the derived class does not have full-trust permission. For details about security demands, see Link Demands and Inheritance Demands.

The following example builds a CodeDOM source graph for a simple Hello World program. The source is then saved to a file, compiled into an executable, and run. The CompileCode method illustrates how to use the CompilerParameters class to specify various compiler settings and options.

Imports System
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.

            ' 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.

            ' 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( _

            ' Build a Console.WriteLine statement. 
            Dim cs1 As New CodeMethodInvokeExpression( _
                csSystemConsoleType, "WriteLine", _
                New CodePrimitiveExpression("Hello World!"))

            ' Add the WriteLine call to the statement collection.

            ' 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.

            ' Build a call to System.Console.ReadLine. 
            Dim csReadLine As New CodeMethodInvokeExpression( _
                csSystemConsoleType, "ReadLine")

            ' Add the ReadLine statement.

            ' Add the code entry point method to the Members 
            ' collection of the type.

            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
                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.

            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.

            ' 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.

                    ' 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.
                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())
                Next ce
                Console.WriteLine("Source {0} built into {1} successfully.", _
                    sourceFile, cr.PathToAssembly)
                Console.WriteLine("{0} temporary files created during the compilation.", _
            End If 

            ' Return the results of compilation. 
            If cr.Errors.Count > 0 Then 
                Return False 
                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()

            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.")
                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

.NET Framework

Supported in: 4.6, 4.5, 4, 3.5, 3.0, 2.0, 1.1

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.
© 2015 Microsoft