CompilerParameters.TempFiles Property


Gets or sets the collection that contains the temporary files.

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

public TempFileCollection TempFiles { get; set; }

Property Value

Type: System.CodeDom.Compiler.TempFileCollection

A collection that contains the temporary files.

The temporary files in the collection are retained or deleted upon the completion of compiler activity based on the value of the KeepFiles property in the collection. The KeepFiles property is set if the collection is created using the TempFileCollection(String, Boolean) constructor with the keepFiles parameter set to true.


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 illustrates using CompilerParameters to specify various compiler settings and options. This code example is part of a larger example provided for the CompilerParameters class.

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.

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

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


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


for full trust for the immediate caller. This member cannot be used by partially trusted code.

.NET Framework
Available since 1.1
Return to top