Membuat dan mengompilasi kode sumber dari grafik CodeDOM

2025-03-25

Namespace layanan System.CodeDom.Compiler menyediakan antarmuka untuk menghasilkan kode sumber dari grafik objek CodeDOM dan untuk mengelola kompilasi dengan kompilator yang didukung. Penyedia kode dapat menghasilkan kode sumber dalam bahasa pemrograman tertentu sesuai dengan grafik CodeDOM. Kelas yang berasal dari CodeDomProvider biasanya dapat menyediakan metode untuk menghasilkan dan mengompilasi kode untuk bahasa yang didukung penyedia.

Menggunakan penyedia kode CodeDOM untuk menghasilkan kode sumber

Untuk menghasilkan kode sumber dalam bahasa tertentu, Anda memerlukan grafik CodeDOM yang mewakili struktur kode sumber yang akan dihasilkan.

Contoh berikut ini menunjukkan cara membuat sebuah instansi dari CSharpCodeProvider:

CSharpCodeProvider^ provider = gcnew CSharpCodeProvider();

CSharpCodeProvider provider = new CSharpCodeProvider();

Dim provider As New CSharpCodeProvider()

Grafik untuk pembuatan kode biasanya terkandung dalam CodeCompileUnit. Untuk menghasilkan kode untuk CodeCompileUnit yang berisi grafik CodeDOM, panggil metode GenerateCodeFromCompileUnit dari penyedia kode. Metode ini memiliki parameter untuk TextWriter yang digunakannya untuk menghasilkan kode sumber, sehingga terkadang perlu membuat TextWriter yang bisa ditulisi terlebih dahulu. Contoh berikut menunjukkan pembuatan kode dari CodeCompileUnit dan menulis kode sumber yang dihasilkan ke file bernama HelloWorld.cs.

public:
    static String^ GenerateCSharpCode(CodeCompileUnit^ compileunit)
    {
        // Generate the code with the C# code provider.
        CSharpCodeProvider^ provider = gcnew CSharpCodeProvider();

        // Build the output file name.
        String^ sourceFile;
        if (provider->FileExtension[0] == '.')
        {
           sourceFile = "HelloWorld" + provider->FileExtension;
        }
        else
        {
           sourceFile = "HelloWorld." + provider->FileExtension;
        }

        // Create a TextWriter to a StreamWriter to the output file.
        StreamWriter^ sw = gcnew StreamWriter(sourceFile, false);
        IndentedTextWriter^ tw = gcnew IndentedTextWriter(sw, "    ");

            // Generate source code using namespace the code provider.
        provider->GenerateCodeFromCompileUnit(compileunit, tw,
            gcnew CodeGeneratorOptions());

        // Close the output file.
        tw->Close();
        sw->Close();

        return sourceFile;
    }

public static string GenerateCSharpCode(CodeCompileUnit compileunit)
{
    // Generate the code with the C# code provider.
    CSharpCodeProvider provider = new CSharpCodeProvider();

    // Build the output file name.
    string sourceFile;
    if (provider.FileExtension[0] == '.')
    {
       sourceFile = "HelloWorld" + provider.FileExtension;
    }
    else
    {
       sourceFile = "HelloWorld." + provider.FileExtension;
    }

    // Create a TextWriter to a StreamWriter to the output file.
    using (StreamWriter sw = new StreamWriter(sourceFile, false))
    {
        IndentedTextWriter tw = new IndentedTextWriter(sw, "    ");

        // Generate source code using the code provider.
        provider.GenerateCodeFromCompileUnit(compileunit, tw,
            new CodeGeneratorOptions());

        // Close the output file.
        tw.Close();
    }

    return sourceFile;
}

Public Shared Function GenerateCSharpCode(compileunit As CodeCompileUnit) As String
    ' Generate the code with the C# code provider.
    Dim provider As New CSharpCodeProvider()

    ' Build the output file name.
    Dim sourceFile As String
    If provider.FileExtension(0) = "." Then
        sourceFile = "HelloWorld" + provider.FileExtension
    Else
        sourceFile = "HelloWorld." + provider.FileExtension
    End If

    ' Create a TextWriter to a StreamWriter to the output file.
    Using sw As New StreamWriter(sourceFile, false)
        Dim tw As New IndentedTextWriter(sw, "    ")

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

        ' Close the output file.
        tw.Close()
    End Using

    Return sourceFile
End Function

Menggunakan penyedia kode CodeDOM untuk mengompilasi rakitan

Mengaktifkan proses kompilasi

Untuk mengompilasi assembly menggunakan penyedia CodeDom, Anda harus memiliki kode sumber untuk dikompilasi dalam bahasa di mana Anda memiliki kompilator, atau dari grafik CodeDOM yang kode sumbernya dapat dihasilkan.

Jika Anda mengompilasi dari grafik CodeDOM, teruskan CodeCompileUnit yang berisi grafik ke metode CompileAssemblyFromDom penyedia kode. Jika Anda memiliki file kode sumber dalam bahasa yang dipahami kompilator, teruskan nama file yang berisi kode sumber ke metode CompileAssemblyFromFile penyedia CodeDom. Anda juga dapat meneruskan string yang berisi kode sumber dalam bahasa yang dipahami kompilator ke metode CompileAssemblyFromSource penyedia CodeDom.

Mengonfigurasi parameter kompilasi

Semua metode pemanggilan kompilasi standar dari penyedia CodeDom memiliki parameter jenis CompilerParameters yang menunjukkan opsi untuk digunakan untuk kompilasi.

Anda dapat menentukan nama file untuk rakitan output dalam properti OutputAssembly dari CompilerParameters. Jika tidak, nama file output default akan digunakan.

Secara bawaan, sebuah CompilerParameters yang baru diinisialisasi dengan propertinya GenerateExecutable diatur ke false. Jika Anda mengkompilasi program yang dapat dieksekusi, Anda harus mengatur properti ke GenerateExecutabletrue. GenerateExecutable Ketika diatur ke false, pengkompilasi akan menghasilkan pustaka kelas.

Jika Anda mengompilasi hal yang dapat dijalankan dari grafik CodeDOM, CodeEntryPointMethod harus ditentukan dalam grafik. Jika ada beberapa titik entri kode, mungkin perlu untuk menetapkan properti MainClass dari CompilerParameters ke nama kelas yang menentukan titik masuk yang akan digunakan.

Untuk menyertakan informasi debug dalam executable yang dihasilkan, atur IncludeDebugInformation properti ke true.

Jika proyek Anda mereferensikan assembly apa pun, Anda harus menentukan nama assembly sebagai item dalam StringCollection dan menetapkannya sebagai properti ReferencedAssemblies dari CompilerParameters yang Anda gunakan 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 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 menautkan file sumber daya Win32 ke dalam rakitan yang dikompilasi, tentukan nama file sumber daya Win32 di properti Win32Resource.

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.

Contoh kode berikut menunjukkan kompilasi file sumber menggunakan penyedia CodeDom yang berasal dari kelas CodeDomProvider.

public:
    static bool CompileCSharpCode(String^ sourceFile, String^ exeFile)
    {
        CSharpCodeProvider^ provider = gcnew CSharpCodeProvider();

        // Build the parameters for source compilation.
        CompilerParameters^ cp = gcnew CompilerParameters();

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

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

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

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

        // 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;
        }
    }

public static bool CompileCSharpCode(string sourceFile, string exeFile)
{
    CSharpCodeProvider provider = new CSharpCodeProvider();

    // Build the parameters for source compilation.
    CompilerParameters cp = new CompilerParameters();

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

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

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

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

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

   if (cr.Errors.Count > 0)
   {
       // Display compilation errors.
        Console.WriteLine($"Errors building {sourceFile} into {cr.PathToAssembly}");
        foreach (CompilerError ce in cr.Errors)
        {
            Console.WriteLine($"  {ce.ToString()}");
            Console.WriteLine();
        }
    }
    else
    {
        Console.WriteLine($"Source {sourceFile} built into {cr.PathToAssembly} successfully.");
    }

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

Public Shared Function CompileCSharpCode(sourceFile As String, _
    exeFile As String) As Boolean
    Dim provider As New CSharpCodeProvider()

    ' Build the parameters for source compilation.
    Dim cp As New CompilerParameters()

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

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

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

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

    ' 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)
        For Each ce As CompilerError In cr.Errors
            Console.WriteLine("  {0}", ce.ToString())
            Console.WriteLine()
        Next ce
    Else
        Console.WriteLine("Source {0} built into {1} successfully.", _
            sourceFile, cr.PathToAssembly)
    End If

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

Bahasa dengan dukungan awal

.NET menyediakan pengkompilasi kode dan generator kode untuk bahasa berikut: C#, Visual Basic, C++, dan JScript. Dukungan CodeDOM dapat diperluas ke bahasa lain dengan menerapkan generator kode khusus bahasa dan kompilator kode.

Bagikan melalui