CompilerParameters Osztály

Definíció

Névtér:

System.CodeDom.Compiler

Szerelvény:

System.CodeDom.dll

Csomag:

System.CodeDom v11.0.0-preview.7.26381.103

Forrás:

CompilerParameters.cs

A fordító meghívásához használt paramétereket jelöli.

public ref class CompilerParameters

public class CompilerParameters

type CompilerParameters = class

Public Class CompilerParameters

Öröklődés

Object

CompilerParameters

Származtatott

System.Workflow.ComponentModel.Compiler.WorkflowCompilerParameters

Példák

Az alábbi példa egy CodeDOM-forrásgráfot készít egy egyszerű „Helló világ!” alkalmazás programhoz. A forrás ezután egy fájlba lesz mentve, végrehajthatóvá lesz fordítva, és futtatható lesz. A CompileCode módszer bemutatja, hogyan használható az osztály a CompilerParameters különböző fordítóbeállítások és beállítások megadására.

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

Megjegyzések

Az CompilerParameters objektumok az interfész beállításait és beállításait ICodeCompiler jelölik.

Ha végrehajtható programot állít össze, a tulajdonságot a GenerateExecutable-ról true-ra kell állítania. Ha az GenerateExecutable érték be van állítva false, a fordító létrehoz egy osztálytárat. Alapértelmezés szerint egy új CompilerParameters inicializálódik, amelynek GenerateExecutable tulajdonsága false értékre van állítva. Ha egy CodeDOM-gráfból állít össze egy végrehajtható fájlt, meg kell határozni egy CodeEntryPointMethod-t a gráfban. Ha több kódbejegyzési pont is van, az osztály nevét a tulajdonságra MainClass állítva jelezheti azt az osztályt, amely meghatározza a használni kívánt belépési pontot.

A tulajdonságban megadhatja a kimeneti szerelvény fájlnevét OutputAssembly . Ellenkező esetben a rendszer egy alapértelmezett kimeneti fájlnevet használ. Ha hibakeresési adatokat szeretne belefoglalni egy létrehozott szerelvénybe, állítsa a tulajdonságot a IncludeDebugInformation következőre true: . Ha a projekt bármilyen összeállításra hivatkozik, a szerelvényneveket elemekként kell megadnia egy StringCollection készletben a ReferencedAssembliesCompilerParameters fordítás meghívásakor használt tulajdonságnak megfelelően.

A tulajdonság beállításával GenerateInMemory a memóriába írt szerelvényt nem lemezre, hanem memóriába truefordíthatja. Amikor a rendszer létrehoz egy szerelvényt a memóriában, a kód a létrehozott szerelvényre mutató hivatkozást szerezhet be a CompiledAssembly tulajdonságból egy CompilerResults-ből. Ha egy szerelvényt lemezre írnak, a létrehozott szerelvény elérési útját a PathToAssembly tulajdonságból egy CompilerResults-ből szerezheti meg.

Ha meg szeretne adni egy figyelmeztetési szintet, amelynél le szeretné állítani a fordítást, állítsa a WarningLevel tulajdonságot egy egész számra, amely azt a figyelmeztetési szintet jelöli, amelyen a fordítást le kell állítani. A fordítót úgy is konfigurálhatja, hogy állítsa le a fordítást, ha figyelmeztetések lépnek fel a TreatWarningsAsErrors tulajdonság truebeállításával.

Ha egyéni parancssori argumentumsztringet szeretne megadni a fordítási folyamat meghívásához, állítsa be a karakterláncot a CompilerOptions tulajdonságban. Ha a fordítófolyamat meghívásához Win32 biztonsági jogkivonatra van szükség, adja meg a jogkivonatot a UserToken tulajdonságban. Ha .NET Keretrendszer erőforrásfájljait fel szeretné venni a lefordított szerelvénybe, adja hozzá az erőforrásfájlok nevét a EmbeddedResources tulajdonsághoz. Ha egy másik szerelvényben .NET Keretrendszer-erőforrásokra szeretne hivatkozni, adja hozzá az erőforrásfájlok nevét a LinkedResources tulajdonsághoz. Ha win32-erőforrásfájlt szeretne felvenni a lefordított szerelvénybe, adja meg a Win32 erőforrásfájl nevét a Win32Resource tulajdonságban.

Note

Ez az osztály az összes tagra vonatkozó hivatkozási és öröklési igényt tartalmaz az osztály szintjén. A SecurityException akkor dobódik, ha az azonnali hívó vagy a származtatott osztály nem rendelkezik teljes megbízhatósági engedéllyel. A biztonsági követelményekkel kapcsolatos részletekért tekintse meg az Igények csatolása és az Öröklési igényekhivatkozása című témakört.

Konstruktorok

Name	Description
CompilerParameters()	Inicializálja a CompilerParameters osztály új példányát.
CompilerParameters(String[], String, Boolean)	Inicializálja az osztály új példányát a CompilerParameters megadott szerelvénynevek, kimeneti név és egy olyan érték használatával, amely jelzi, hogy szerepeljenek-e hibakeresési információk.
CompilerParameters(String[], String)	Inicializálja az osztály új példányát a CompilerParameters megadott szerelvénynevek és kimeneti fájlnév használatával.
CompilerParameters(String[])	Inicializálja az CompilerParameters osztály új példányát a megadott szerelvénynevek használatával.

Tulajdonságok

Name	Description
CompilerOptions	Lekéri vagy beállítja a fordító meghívásakor használandó választható parancssori argumentumokat.
CoreAssemblyFileName	Lekéri vagy beállítja annak a magnak vagy standard szerelvénynek a nevét, amely olyan alaptípusokat tartalmaz, mint az Object, Stringvagy Int32.
EmbeddedResources	Lekéri a .NET erőforrásfájlokat a szerelvény kimenetének összeállítása során.
GenerateExecutable	Lekéri vagy beállít egy értéket, amely jelzi, hogy létre kell-e hozni egy végrehajtható fájlt.
GenerateInMemory	Lekéri vagy beállít egy értéket, amely jelzi, hogy a kimenetet a memóriában szeretné-e létrehozni.
IncludeDebugInformation	Lekéri vagy beállít egy értéket, amely jelzi, hogy szerepeljenek-e hibakeresési információk a lefordított végrehajtható fájlban.
LinkedResources	Lekéri az aktuális forrásban hivatkozott .NET erőforrásfájlokat.
MainClass	Lekéri vagy beállítja a főosztály nevét.
OutputAssembly	Lekéri vagy beállítja a kimeneti szerelvény nevét.
ReferencedAssemblies	Lekéri az aktuális projekt által hivatkozott szerelvényeket.
TempFiles	Lekéri vagy beállítja az ideiglenes fájlokat tartalmazó gyűjteményt.
TreatWarningsAsErrors	Lekéri vagy beállít egy értéket, amely jelzi, hogy a figyelmeztetéseket hibaként kell-e kezelni.
UserToken	Lekéri vagy beállítja a felhasználói jogkivonatot a fordítófolyamat létrehozásakor.
WarningLevel	Lekéri vagy beállítja azt a figyelmeztetési szintet, amelyen a fordító megszakítja a fordítást.
Win32Resource	Lekéri vagy beállítja egy Win32-erőforrásfájl fájlnevét a lefordított szerelvényre való hivatkozáshoz.