CompilerParameters CompilerParameters CompilerParameters CompilerParameters Class

Определение

Представляет параметры, используемые для вызова компилятора.Represents the parameters used to invoke a compiler.

public ref class CompilerParameters
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class CompilerParameters
type CompilerParameters = class
Public Class CompilerParameters
Наследование
CompilerParametersCompilerParametersCompilerParametersCompilerParameters
Производный
Атрибуты

Примеры

В следующем примере показана сборка графа исходного кода CodeDOM для простой Hello World программы.The following example builds a CodeDOM source graph for a simple Hello World program. Затем источник сохраняется в файле, компилируется в исполняемый файл и выполняется.The source is then saved to a file, compiled into an executable, and run. Метод показывает, как CompilerParameters использовать класс для задания различных параметров компилятора и параметров. CompileCodeThe CompileCode method illustrates how to use the CompilerParameters class to specify various compiler settings and options.

using namespace System;
using namespace System::CodeDom;
using namespace System::CodeDom::Compiler;
using namespace System::Collections;
using namespace System::ComponentModel;
using namespace System::IO;
using namespace System::Diagnostics;

// Build a Hello World program graph using System.CodeDom types.
static CodeCompileUnit^ BuildHelloWorldGraph()
{
   // Create a new CodeCompileUnit to contain the program graph.
   CodeCompileUnit^ compileUnit = gcnew CodeCompileUnit;
   
   // Declare a new namespace called Samples.
   CodeNamespace^ samples = gcnew 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( gcnew CodeNamespaceImport( "System" ) );
   
   // Declare a new type called Class1.
   CodeTypeDeclaration^ class1 = gcnew 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 = gcnew CodeEntryPointMethod;
   
   // Create a type reference for the System::Console class.
   CodeTypeReferenceExpression^ csSystemConsoleType =
      gcnew CodeTypeReferenceExpression( "System.Console" );
   
   // Build a Console::WriteLine statement.
   CodeMethodInvokeExpression^ cs1 = gcnew CodeMethodInvokeExpression(
      csSystemConsoleType, "WriteLine",
      gcnew CodePrimitiveExpression( "Hello World!" ) );
   
   // Add the WriteLine call to the statement collection.
   start->Statements->Add( cs1 );
   
   // Build another Console::WriteLine statement.
   CodeMethodInvokeExpression^ cs2 = gcnew CodeMethodInvokeExpression(
      csSystemConsoleType, "WriteLine",
      gcnew 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.
   CodeMethodReferenceExpression^ csReadLine = gcnew CodeMethodReferenceExpression(
      csSystemConsoleType, "ReadLine" );
   CodeMethodInvokeExpression^ cs3 = gcnew CodeMethodInvokeExpression(
      csReadLine,gcnew array<CodeExpression^>(0) );
   
   // Add the ReadLine statement.
   start->Statements->Add( cs3 );
   
   // Add the code entry point method to the Members collection
   // of the type.
   class1->Members->Add( start );

   return compileUnit;
}

static String^ GenerateCode( CodeDomProvider^ provider, CodeCompileUnit^ compileunit )
{
   // Build the source file name with the language extension (vb, cs, js).
   String^ sourceFile = String::Empty;

      if ( provider->FileExtension->StartsWith( "." ) )
      {
         sourceFile = String::Concat( "HelloWorld", provider->FileExtension );
      }
      else
      {
         sourceFile = String::Concat( "HelloWorld.", provider->FileExtension );
      }

      // Create a TextWriter to a StreamWriter to an output file.
      IndentedTextWriter^ tw = gcnew IndentedTextWriter(
         gcnew StreamWriter( sourceFile,false ),"    " );
      // Generate source code using the code generator.
      provider->GenerateCodeFromCompileUnit( compileunit, tw, gcnew CodeGeneratorOptions );
      // Close the output file.
      tw->Close();
   return sourceFile;
}

static bool CompileCode( CodeDomProvider^ provider,
   String^ sourceFile,
   String^ exeFile )
{

   CompilerParameters^ cp = gcnew CompilerParameters;
   if ( !cp)  
   {
      return false;
   }

   // 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 = gcnew 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 );
      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;
   }
}

[STAThread]
void main()
{
   String^ exeName = "HelloWorld.exe";
   CodeDomProvider^ provider = nullptr;

   Console::WriteLine( "Enter the source language for Hello World (cs, vb, etc):" );
   String^ inputLang = Console::ReadLine();
   Console::WriteLine();

   if ( CodeDomProvider::IsDefinedLanguage( inputLang ) )
   {
      CodeCompileUnit^ helloWorld = BuildHelloWorldGraph();
      provider = CodeDomProvider::CreateProvider( inputLang );
      if ( helloWorld && provider )
      {
         String^ sourceFile = GenerateCode( provider, helloWorld );
         Console::WriteLine( "HelloWorld source code generated." );
         if ( CompileCode( provider, sourceFile, exeName ) )
         {
            Console::WriteLine( "Starting HelloWorld executable." );
            Process::Start( exeName );
         }
      }
   }

   if ( provider == nullptr )
   {
      Console::WriteLine( "There is no CodeDomProvider for the input language." );
   }
}
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
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 'Main 

    End Class 'CompileClass
End Namespace

Комментарии

Объект представляет параметры и параметры ICodeCompiler для интерфейса. CompilerParametersA CompilerParameters object represents the settings and options for an ICodeCompiler interface.

При компиляции исполняемой программы необходимо задать GenerateExecutable для trueсвойства значение.If you are compiling an executable program, you must set the GenerateExecutable property to true. Если параметр falseимеет значение, компилятор создаст библиотеку классов. GenerateExecutableWhen the GenerateExecutable is set to false, the compiler will generate a class library. По умолчанию новый CompilerParameters объект инициализируется GenerateExecutable со свойством, имеющим значение false.By default, a new CompilerParameters is initialized with its GenerateExecutable property set to false. При компиляции исполняемой программы из графа CodeDOM следует определить в графе объект CodeEntryPointMethod.If you are compiling an executable from a CodeDOM graph, a CodeEntryPointMethod must be defined in the graph. Если имеется несколько точек входа в код, можно указать класс, определяющий используемую точку входа, задав имя класса для MainClass свойства.If there are multiple code entry points, you can indicate the class that defines the entry point to use by setting the name of the class to the MainClass property.

В OutputAssembly свойстве можно указать имя файла для выходной сборки.You can specify a file name for the output assembly in the OutputAssembly property. В противном случае будет использоваться имя выходного файла по умолчанию.Otherwise, a default output file name will be used. Чтобы включить отладочную информацию в созданную сборку, задайте IncludeDebugInformation для trueсвойства значение.To include debug information in a generated assembly, set the IncludeDebugInformation property to true. Если проект ссылается на какие-либо сборки, необходимо указать имена сборок как элементы в StringCollection наборе ReferencedAssemblies для свойства объекта, CompilerParameters используемого при вызове компиляции.If your project references any assemblies, you must specify the assembly names as items in a StringCollection set to the ReferencedAssemblies property of the CompilerParameters used when invoking compilation.

Сборку, которая записывается в память, а не на диск, можно скомпилировать GenerateInMemory , задав trueдля свойства значение.You can compile an assembly that is written to memory rather than disk by setting the GenerateInMemory property to true. При создании сборки в памяти код может получить ссылку на создаваемую сборку из свойства CompiledAssembly объекта CompilerResults.When an assembly is generated in memory, your code can obtain a reference to the generated assembly from the CompiledAssembly property of a CompilerResults. Если сборка записывается на диск, можно получить путь к созданной сборке из PathToAssembly свойства. CompilerResultsIf an assembly is written to disk, you can obtain the path to the generated assembly from the PathToAssembly property of a CompilerResults.

Чтобы указать уровень предупреждения, на котором следует прекратить компиляцию, задайте свойство WarningLevel как целое число, представляющее уровень предупреждения для прекращения компиляции.To specify a warning level at which to halt compilation, set the WarningLevel property to an integer that represents the warning level at which to halt compilation. Можно также настроить компилятор на остановку компиляции при обнаружении предупреждений, задав TreatWarningsAsErrors для trueсвойства значение.You can also configure the compiler to halt compilation if warnings are encountered by setting the TreatWarningsAsErrors property to true.

Чтобы указать пользовательскую строку аргументов командной строки, которую следует использовать при вызове процесса компиляции, задайте строку в свойстве CompilerOptions.To specify a custom command-line arguments string to use when invoking the compilation process, set the string in the CompilerOptions property. Если для вызова процесса компилятора требуется маркер безопасности Win32, задайте этот маркер в свойстве UserToken.If a Win32 security token is required to invoke the compiler process, specify the token in the UserToken property. Чтобы включить .NET Framework файлы ресурсов в скомпилированную сборку, добавьте имена файлов EmbeddedResources ресурсов в свойство.To include .NET Framework resource files in the compiled assembly, add the names of the resource files to the EmbeddedResources property. Для ссылки на .NET Framework ресурсы в другой сборке добавьте имена файлов LinkedResources ресурсов в свойство.To reference .NET Framework resources in another assembly, add the names of the resource files to the LinkedResources property. Чтобы включить файл ресурсов Win32 в скомпилированную сборку, укажите имя файла ресурсов Win32 в Win32Resource свойстве.To include a Win32 resource file in the compiled assembly, specify the name of the Win32 resource file in the Win32Resource property.

Примечание

Этот класс содержит требования связывания и наследования на уровне класса, которые применяются ко всем элементам.This class contains a link demand and an inheritance demand at the class level that applies to all members. Если непосредственно вызывающий оператор или производный класс не имеет разрешения полного доверия, возникает исключение SecurityException.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.

Конструкторы

CompilerParameters() CompilerParameters() CompilerParameters() CompilerParameters()

Инициализирует новый экземпляр класса CompilerParameters.Initializes a new instance of the CompilerParameters class.

CompilerParameters(String[]) CompilerParameters(String[]) CompilerParameters(String[]) CompilerParameters(String[])

Инициализирует новый экземпляр класса CompilerParameters с использованием указанных имен сборок.Initializes a new instance of the CompilerParameters class using the specified assembly names.

CompilerParameters(String[], String) CompilerParameters(String[], String) CompilerParameters(String[], String) CompilerParameters(String[], String)

Инициализирует новый экземпляр класса CompilerParameters, используя указанные имена сборок и имя выходного файла.Initializes a new instance of the CompilerParameters class using the specified assembly names and output file name.

CompilerParameters(String[], String, Boolean) CompilerParameters(String[], String, Boolean) CompilerParameters(String[], String, Boolean) CompilerParameters(String[], String, Boolean)

Инициализирует новый экземпляр класса CompilerParameters, используя указанные имена сборок, имя выходного файла и значение, показывающее, следует ли включать сведения об отладке.Initializes a new instance of the CompilerParameters class using the specified assembly names, output name, and a value indicating whether to include debug information.

Свойства

CompilerOptions CompilerOptions CompilerOptions CompilerOptions

Получает или задает необязательный аргументы командной строки для использования при вызове компилятора.Gets or sets optional command-line arguments to use when invoking the compiler.

CoreAssemblyFileName CoreAssemblyFileName CoreAssemblyFileName CoreAssemblyFileName

Получает или задает имя основной или стандартной сборки, которая содержит базовые типы, такие как Object, String или Int32.Gets or sets the name of the core or standard assembly that contains basic types such as Object, String, or Int32.

EmbeddedResources EmbeddedResources EmbeddedResources EmbeddedResources

Получает файлы ресурсов платформы .NET Framework для включения при компиляции вывода сборки.Gets the .NET Framework resource files to include when compiling the assembly output.

Evidence Evidence Evidence Evidence

Указывает объект свидетельства, представляющий разрешения политики безопасности для предоставления компилируемой сборке.Specifies an evidence object that represents the security policy permissions to grant the compiled assembly.

GenerateExecutable GenerateExecutable GenerateExecutable GenerateExecutable

Получает или задает значение, показывающее, следует ли создавать исполняемый файл.Gets or sets a value indicating whether to generate an executable.

GenerateInMemory GenerateInMemory GenerateInMemory GenerateInMemory

Получает или задает значение, показывающее, следует ли создавать выходной файл в памяти.Gets or sets a value indicating whether to generate the output in memory.

IncludeDebugInformation IncludeDebugInformation IncludeDebugInformation IncludeDebugInformation

Получает или задает значение, показывающее, следует ли включать сведения об отладке в компилируемый исполняемый файл.Gets or sets a value indicating whether to include debug information in the compiled executable.

LinkedResources LinkedResources LinkedResources LinkedResources

Получает файлы ресурсов платформы .NET Framework, на которые имеются ссылки в текущем источнике.Gets the .NET Framework resource files that are referenced in the current source.

MainClass MainClass MainClass MainClass

Получает или задает имя главного класса.Gets or sets the name of the main class.

OutputAssembly OutputAssembly OutputAssembly OutputAssembly

Получает или задает имя выходной сборки.Gets or sets the name of the output assembly.

ReferencedAssemblies ReferencedAssemblies ReferencedAssemblies ReferencedAssemblies

Получает или задает сборки, на которые ссылается текущий проект.Gets the assemblies referenced by the current project.

TempFiles TempFiles TempFiles TempFiles

Получает или задает коллекцию временных файлов.Gets or sets the collection that contains the temporary files.

TreatWarningsAsErrors TreatWarningsAsErrors TreatWarningsAsErrors TreatWarningsAsErrors

Получает или задает значение, указывающее, следует ли интерпретировать предупреждения как ошибки.Gets or sets a value indicating whether to treat warnings as errors.

UserToken UserToken UserToken UserToken

Получает или задает пользовательский токен, используемый при создании процесса компилятора.Gets or sets the user token to use when creating the compiler process.

WarningLevel WarningLevel WarningLevel WarningLevel

Получает или задает уровень предупреждения, на котором компилятор прекращает компиляцию.Gets or sets the warning level at which the compiler aborts compilation.

Win32Resource Win32Resource Win32Resource Win32Resource

Получает или задает имя файла ресурса Win32 для связывания с компилируемой сборкой.Gets or sets the file name of a Win32 resource file to link into the compiled assembly.

Методы

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Определяет, равен ли заданный объект текущему объекту.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Служит хэш-функцией по умолчанию.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Возвращает объект Type для текущего экземпляра.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Создает неполную копию текущего объекта Object.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Возвращает строку, представляющую текущий объект.Returns a string that represents the current object.

(Inherited from Object)

Безопасность

LinkDemand
Полный уровень доверия для непосредственного вызывающего.for full trust for the immediate caller. Этот класс нельзя использовать в частично доверенном коде.This class cannot be used by partially trusted code.

InheritanceDemand
Полный уровень доверия для разработчиков производных классов.for full trust for inheritors. Этот класс не может наследоваться частично доверенным кодом.This class cannot be inherited by partially trusted code.

Применяется к