CompilerParameters Sınıf

Tanım

Ad Alanı:

System.CodeDom.Compiler

Bütünleştirilmiş Kod:

System.CodeDom.dll

Kaynak:

CompilerParameters.cs

Derleyici çağırmak için kullanılan parametreleri temsil eder.

public ref class CompilerParameters

public class CompilerParameters

type CompilerParameters = class

Public Class CompilerParameters

Devralma

Object

CompilerParameters

Türetilmiş

System.Workflow.ComponentModel.Compiler.WorkflowCompilerParameters

Örnekler

Aşağıdaki örnek, basit bir Hello World programı için codedom kaynak grafı oluşturur. Ardından kaynak bir dosyaya kaydedilir, yürütülebilir dosyaya derlenip çalıştırılır. yöntemi, CompileCode çeşitli derleyici ayarlarını ve seçeneklerini belirtmek için sınıfının nasıl kullanılacağını CompilerParameters gösterir.

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

Açıklamalar

CompilerParameters Nesne, bir ICodeCompiler arabirimin ayarlarını ve seçeneklerini temsil eder.

Yürütülebilir bir program derliyorsanız, GenerateExecutable özelliğini true olarak ayarlamanız gerekir. GenerateExecutable olarak ayarlandığındafalse, derleyici bir sınıf kitaplığı oluşturur. Varsayılan olarak, yeni bir CompilerParameters, GenerateExecutable özelliği false olacak şekilde başlatılır. CodeDOM grafiğinden yürütülebilir dosya derlediyseniz, CodeEntryPointMethod grafikte tanımlanmalıdır. Birden çok kod giriş noktası varsa, sınıfın adını özelliğine ayarlayarak kullanılacak giriş noktasını tanımlayan sınıfı MainClass belirtebilirsiniz.

özelliğindeki OutputAssembly çıkış derlemesi için bir dosya adı belirtebilirsiniz. Aksi takdirde, varsayılan bir çıkış dosyası adı kullanılır. Oluşturulan derlemeye hata ayıklama bilgilerini eklemek için özelliğini olarak trueayarlayınIncludeDebugInformation. Projeniz herhangi bir derlemeye başvuruda bulunursa derleme adlarını derleme çağrılırken kullanılan özelliğinin bir CompilerParameters kümesinde ReferencedAssembliesStringCollection öğeler olarak belirtmeniz gerekir.

özelliğini GenerateInMemoryolarak ayarlayarak disk yerine belleğe yazılan bir derleme derleyebilirsiniztrue. Kodunuz bellekte bir derleme oluşturulduğunda, bir CompiledAssembly özelliğinden CompilerResults oluşturulan derlemeye başvuru alabilir. Bir derleme diske yazılırsa, oluşturulan derlemenin yolunu 'in özelliğinden alabilirsiniz.

Derlemenin durdurulması gereken bir uyarı düzeyi belirtmek için, özelliğini derlemenin WarningLevel durdurulduğu uyarı düzeyini temsil eden bir tamsayıya ayarlayın. Ayrıca özelliğini TreatWarningsAsErrorsolarak ayarlayarak uyarılarla karşılaşılırsa derleyiciyi derlemeyi true durduracak şekilde yapılandırabilirsiniz.

Derleme işlemi çağrılırken kullanılacak özel bir komut satırı argüman dizisini belirtmek için dizeyi CompilerOptions özelliği olarak ayarlayın. Derleyici işlemini çağırmak için bir Win32 güvenlik belirteci gerekiyorsa, özelliğinde UserToken belirteci belirtin. Derlenen derlemeye .NET Framework kaynak dosyalarını eklemek için, kaynak dosyalarının adlarını özelliğine EmbeddedResources ekleyin. Başka bir derlemedeki .NET Framework kaynaklarına başvurmak için, kaynak dosyalarının adlarını özelliğine LinkedResources ekleyin. Derlenen derlemeye bir Win32 kaynak dosyası eklemek için özelliğindeki Win32 kaynak dosyasının Win32Resource adını belirtin.

Uyarı

Bu sınıf, tüm üyeler için geçerli olan sınıf düzeyinde bir bağlantı talebi ve devralma talebi içerir. Hemen SecurityException çağıranın veya türetilen sınıfın tam güven izni olmadığında bir hata fırlatılır. Güvenlik talepleri hakkında ayrıntılı bilgi için bkz. Bağlantı Talepleri ve Devralma Talepleri.

Oluşturucular

Name	Description
CompilerParameters()	CompilerParameters sınıfının yeni bir örneğini başlatır.
CompilerParameters(String[], String, Boolean)	Belirtilen derleme adlarını, çıkış adını ve hata ayıklama bilgilerinin eklenip eklenmeyeceğini CompilerParameters belirten bir değeri kullanarak sınıfın yeni bir örneğini başlatır.
CompilerParameters(String[], String)	Belirtilen derleme adlarını ve çıkış dosyası adını kullanarak sınıfın yeni bir örneğini CompilerParameters başlatır.
CompilerParameters(String[])	Belirtilen derleme adlarını kullanarak sınıfın CompilerParameters yeni bir örneğini başlatır.

Özellikler

Name	Description
CompilerOptions	Derleyici çağrılırken kullanılacak isteğe bağlı komut satırı bağımsız değişkenlerini alır veya ayarlar.
CoreAssemblyFileName	, Stringveya gibi Objecttemel türleri içeren çekirdek veya standart derlemenin adını alır veya Int32ayarlar.
EmbeddedResources	Derleme çıktısı derlenirken eklenecek .NET kaynak dosyalarını alır.
GenerateExecutable	Yürütülebilir dosya oluşturulup oluşturulmayacağını belirten bir değer alır veya ayarlar.
GenerateInMemory	Çıktının bellekte oluşturulup oluşturulmayacağını belirten bir değer alır veya ayarlar.
IncludeDebugInformation	Derlenmiş yürütülebilir dosyaya hata ayıklama bilgilerinin eklenip eklenmeyeceğini belirten bir değer alır veya ayarlar.
LinkedResources	Geçerli kaynakta başvuruda bulunan .NET kaynak dosyalarını alır.
MainClass	Ana sınıfın adını alır veya ayarlar.
OutputAssembly	Çıkış derlemesinin adını alır veya ayarlar.
ReferencedAssemblies	Geçerli proje tarafından başvuruda bulunan derlemeleri alır.
TempFiles	Geçici dosyaları içeren koleksiyonu alır veya ayarlar.
TreatWarningsAsErrors	Uyarıların hata olarak ele alıp almayacağını belirten bir değer alır veya ayarlar.
UserToken	Derleyici işlemi oluşturulurken kullanılacak kullanıcı belirtecini alır veya ayarlar.
WarningLevel	Derleyicinin derlemeyi iptal ettiği uyarı düzeyini alır veya ayarlar.
Win32Resource	Derlenen derlemeye bağlanmak için Win32 kaynak dosyasının dosya adını alır veya ayarlar.