CompilerParameters Kelas

Definisi

Ruang nama:

System.CodeDom.Compiler

Rakitan:

System.CodeDom.dll

Sumber:

CompilerParameters.cs

Mewakili parameter yang digunakan untuk memanggil pengkompilasi.

public ref class CompilerParameters

public class CompilerParameters

type CompilerParameters = class

Public Class CompilerParameters

Warisan

Object

CompilerParameters

Turunan

System.Workflow.ComponentModel.Compiler.WorkflowCompilerParameters

Contoh

Contoh berikut membangun grafik sumber CodeDOM untuk program Hello World sederhana. Sumber kemudian disimpan ke file, dikompilasi ke dalam executable, dan dijalankan. Metode ini CompileCode menggambarkan CompilerParameters cara menggunakan kelas untuk menentukan berbagai pengaturan dan opsi pengkompilasi.

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

    End Class
End Namespace

Keterangan

Objek CompilerParameters mewakili pengaturan dan opsi untuk ICodeCompiler antarmuka.

Jika Anda mengkompilasi program yang dapat dieksekusi, Anda harus mengatur properti ke GenerateExecutabletrue. GenerateExecutable Ketika diatur ke false, pengkompilasi akan menghasilkan pustaka kelas. Secara bawaan, sebuah CompilerParameters yang baru diinisialisasi dengan propertinya GenerateExecutable diatur ke false. Jika Anda mengompilasi hal yang dapat dijalankan dari grafik CodeDOM, CodeEntryPointMethod harus ditentukan dalam grafik. Jika ada beberapa titik entri kode, Anda dapat menunjukkan kelas yang menentukan titik masuk yang akan digunakan dengan mengatur nama kelas ke MainClass properti .

Anda dapat menentukan nama file untuk rakitan output di OutputAssembly properti . Jika tidak, nama file output default akan digunakan. Untuk menyertakan informasi debug dalam rakitan yang dihasilkan, atur properti ke IncludeDebugInformationtrue. Jika proyek Anda mereferensikan rakitan apa pun, Anda harus menentukan nama rakitan sebagai item dalam set StringCollection ke ReferencedAssemblies properti yang CompilerParameters digunakan saat memanggil kompilasi.

Anda dapat mengompilasi assembly yang ditulis di memori dibanding di disk dengan mengatur properti GenerateInMemory ke true. Ketika rakitan dibuat dalam memori, kode Anda dapat memperoleh referensi ke rakitan yang dihasilkan dari properti CompiledAssembly pada CompilerResults. Jika rakitan ditulis ke disk, Anda dapat memperoleh jalur ke rakitan yang dihasilkan dari properti PathToAssemblyCompilerResults.

Untuk menentukan tingkat peringatan untuk menghentikan kompilasi, atur properti WarningLevel ke bilangan bulat yang mewakili tingkat peringatan untuk menghentikan kompilasi. Anda juga dapat mengonfigurasi kompilator untuk menghentikan kompilasi jika peringatan ditemui dengan mengatur TreatWarningsAsErrors properti ke true.

Untuk menentukan string argumen baris perintah kustom yang akan digunakan saat memanggil proses kompilasi, atur string dalam properti CompilerOptions. Jika token keamanan Win32 diperlukan untuk memanggil proses kompilator, tentukan token di properti UserToken. Untuk menyertakan file sumber daya .NET Framework dalam rakitan yang dikompilasi, tambahkan nama file sumber daya ke EmbeddedResources properti . Untuk mereferensikan sumber daya .NET Framework di rakitan lain, tambahkan nama file sumber daya ke LinkedResources properti . Untuk menyertakan file sumber daya Win32 dalam rakitan yang dikompilasi, tentukan nama file sumber daya Win32 di Win32Resource properti .

Nota

Kelas ini berisi permintaan tautan dan permintaan warisan di tingkat kelas yang berlaku untuk semua anggota. Dilemparkan SecurityException ketika pemanggil langsung atau kelas turunan tidak memiliki izin kepercayaan penuh. Untuk detail tentang tuntutan keamanan, lihat Permintaan Tautan dan Permintaan Warisan.

Konstruktor

Nama	Deskripsi
CompilerParameters()	Menginisialisasi instans baru dari kelas CompilerParameters.
CompilerParameters(String[], String, Boolean)	Menginisialisasi instans CompilerParameters baru kelas menggunakan nama rakitan, nama output, dan nilai yang menunjukkan apakah akan menyertakan informasi debug.
CompilerParameters(String[], String)	Menginisialisasi instans CompilerParameters baru kelas menggunakan nama rakitan dan nama file output yang ditentukan.
CompilerParameters(String[])	Menginisialisasi instans CompilerParameters baru kelas menggunakan nama rakitan yang ditentukan.

Properti

Nama	Deskripsi
CompilerOptions	Mendapatkan atau mengatur argumen baris perintah opsional untuk digunakan saat memanggil pengkompilasi.
CoreAssemblyFileName	Mendapatkan atau mengatur nama inti atau rakitan standar yang berisi jenis dasar seperti Object, , Stringatau Int32.
EmbeddedResources	Mendapatkan file sumber daya .NET untuk disertakan saat mengkompilasi output perakitan.
GenerateExecutable	Mendapatkan atau menetapkan nilai yang menunjukkan apakah akan menghasilkan executable.
GenerateInMemory	Mendapatkan atau menetapkan nilai yang menunjukkan apakah akan menghasilkan output dalam memori.
IncludeDebugInformation	Mendapatkan atau menetapkan nilai yang menunjukkan apakah akan menyertakan informasi debug dalam executable yang dikompilasi.
LinkedResources	Mendapatkan file sumber daya .NET yang dirujuk di sumber saat ini.
MainClass	Mendapatkan atau menetapkan nama kelas utama.
OutputAssembly	Mendapatkan atau mengatur nama rakitan output.
ReferencedAssemblies	Mendapatkan rakitan yang dirujuk oleh proyek saat ini.
TempFiles	Mendapatkan atau mengatur koleksi yang berisi file sementara.
TreatWarningsAsErrors	Mendapatkan atau menetapkan nilai yang menunjukkan apakah akan memperlakukan peringatan sebagai kesalahan.
UserToken	Mendapatkan atau mengatur token pengguna yang akan digunakan saat membuat proses pengkompilasi.
WarningLevel	Mendapatkan atau mengatur tingkat peringatan di mana kompilator membatalkan kompilasi.
Win32Resource	Mendapatkan atau mengatur nama file file sumber daya Win32 untuk ditautkan ke dalam rakitan yang dikompilasi.