CompilerParameters Klasse
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Stellt die zum Aufrufen eines Compilers verwendeten Parameter dar.
public ref class CompilerParameters
public class CompilerParameters
[System.Runtime.InteropServices.ComVisible(false)]
public class CompilerParameters
[System.Serializable]
public class CompilerParameters
type CompilerParameters = class
[<System.Runtime.InteropServices.ComVisible(false)>]
type CompilerParameters = class
[<System.Serializable>]
type CompilerParameters = class
Public Class CompilerParameters
- Vererbung
-
CompilerParameters
- Abgeleitet
- Attribute
Beispiele
Im folgenden Beispiel wird ein CodeDOM-Quelldiagramm für ein einfaches Hello World-Programm erstellt. Die Quelle wird dann in einer Datei gespeichert, in eine ausführbare Datei kompiliert und ausgeführt. Die CompileCode
-Methode veranschaulicht, wie die CompilerParameters -Klasse verwendet wird, um verschiedene Compilereinstellungen und -optionen anzugeben.
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.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
Hinweise
Ein CompilerParameters -Objekt stellt die Einstellungen und Optionen für eine ICodeCompiler Schnittstelle dar.
Wenn Sie ein ausführbares Programm kompilieren, müssen Sie die GenerateExecutable -Eigenschaft auf true
festlegen. Wenn auf GenerateExecutable festgelegt false
ist, generiert der Compiler eine Klassenbibliothek. Standardmäßig wird eine neue CompilerParameters initialisiert, wobei die GenerateExecutable -Eigenschaft auf false
festgelegt ist. Wenn Sie eine ausführbare Datei aus einem CodeDOM-Diagramm kompilieren, muss eine CodeEntryPointMethod im Diagramm definiert werden. Wenn mehrere Codeeingabepunkte vorhanden sind, können Sie die Klasse angeben, die den zu verwendenden Einstiegspunkt definiert, indem Sie den Namen der Klasse auf die MainClass -Eigenschaft festlegen.
Sie können einen Dateinamen für die Ausgabeassembly in der OutputAssembly -Eigenschaft angeben. Andererseits wird ein Standardname für die Ausgabedatei verwendet. Um Debuginformationen in eine generierte Assembly einzuschließen, legen Sie die IncludeDebugInformation -Eigenschaft auf fest true
. Wenn Ihr Projekt auf Assemblys verweist, müssen Sie die Assemblynamen als Elemente in einem StringCollection Satz für die ReferencedAssemblies Eigenschaft der beim Aufrufen der CompilerParameters Kompilierung verwendeten angeben.
Sie können eine Assembly kompilieren, die in den Arbeitsspeicher und nicht in den Datenträger geschrieben wird, indem Sie die GenerateInMemory -Eigenschaft auf true
festlegen. Wenn eine Assembly im Speicher generiert wird, kann Ihr Code einen Verweis aus einer CompiledAssembly-Eigenschaft einer CompilerResults für die generierte Assembly abrufen. Wenn eine Assembly auf den Datenträger geschrieben wird, können Sie den Pfad zur generierten Assembly aus der PathToAssembly -Eigenschaft eines CompilerResultsabrufen.
Wenn Sie eine Warnstufe angeben möchten, an der Sie die Kompilierung anhalten möchten, legen Sie die WarningLevel-Eigenschaft auf einen Integer fest, der die Warnstufe darstellt, an der die Kompilierung angehalten werden soll. Sie können den Compiler auch so konfigurieren, dass die Kompilierung beendet wird, wenn Warnungen auftreten, indem Sie die TreatWarningsAsErrors -Eigenschaft auf true
festlegen.
Um einen benutzerdefinierte Argumentzeichenfolge auf Befehlszeilenebene anzugeben, die Sie beim Aufruf des Kompilierungsprozesses verwenden, legen Sie die Zeichenfolge in der CompilerOptions-Eigenschaft fest. Wenn ein Win32-Sicherheitstoken erforderlich ist, um den Compilerprozess auszurufen, geben Sie das Token in der UserToken-Eigenschaft an. Um .NET Framework-Ressourcendateien in die kompilierte Assembly einzuschließen, fügen Sie der -Eigenschaft die Namen der Ressourcendateien hinzu EmbeddedResources . Um auf .NET Framework-Ressourcen in einer anderen Assembly zu verweisen, fügen Sie der -Eigenschaft die Namen der Ressourcendateien hinzu LinkedResources . Um eine Win32-Ressourcendatei in die kompilierte Assembly einzuschließen, geben Sie den Namen der Win32-Ressourcendatei in der -Eigenschaft an Win32Resource .
Hinweis
Diese Klasse enthält eine Linkanforderung und eine Vererbungsanforderung auf Klassenebene, die für alle Member gilt. Ein SecurityException wird ausgelöst, wenn entweder der unmittelbare Aufrufer oder die abgeleitete Klasse keine voll vertrauenswürdige Berechtigung hat. Ausführliche Informationen zu Sicherheitsanforderungen finden Sie unter Verknüpfen von Anforderungen und Erbansprüchen.
Konstruktoren
CompilerParameters() |
Initialisiert eine neue Instanz der CompilerParameters-Klasse. |
CompilerParameters(String[]) |
Initialisiert eine neue Instanz der CompilerParameters-Klasse mit den angegebenen Assemblynamen. |
CompilerParameters(String[], String) |
Initialisiert eine neue Instanz der CompilerParameters-Klasse mit den angegebenen Assemblynamen und dem Ausgabedateinamen. |
CompilerParameters(String[], String, Boolean) |
Initialisiert eine neue Instanz der CompilerParameters-Klasse mit den Angaben für die Assemblynamen und den Ausgabedateinamen sowie einem Wert, der die eventuelle Einbindung von Debuginformationen angibt. |
Eigenschaften
CompilerOptions |
Ruft die optionalen Befehlszeilenargumente ab, die beim Aufrufen des Compilers verwendet werden soll, oder legt diese fest. |
CoreAssemblyFileName |
Ruft den Namen des Kern- oder Standard-Assemblys ab, das grundlegende Typen wie Object, String oder Int32 enthält, oder legt diesen fest. |
EmbeddedResources |
Ruft die .NET-Ressourcendateien ab, die in das Kompilieren der Assemblyausgabe eingeschlossen werden sollen. |
Evidence |
Veraltet.
Gibt ein Beweisobjekt an, das die Sicherheitsrichtlinienberechtigungen angibt, die der kompilierten Assembly gewährt werden sollen. |
GenerateExecutable |
Ruft einen Wert ab, der angibt, ob eine ausführbare Datei generiert werden soll, oder legt diesen fest. |
GenerateInMemory |
Ruft einen Wert ab, der angibt, ob die Ausgabe im Speicher generiert werden soll, oder legt diesen fest. |
IncludeDebugInformation |
Ruft einen Wert ab, der angibt, ob Debuginformationen in die kompilierte ausführbare Datei aufgenommen werden sollen, oder legt diesen fest. |
LinkedResources |
Ruft die .NET-Ressourcendateien ab, auf die in der aktuellen Quelle verwiesen wird. |
MainClass |
Ruft den Namen der Hauptklasse ab oder legt diesen fest. |
OutputAssembly |
Ruft den Namen der Ausgabeassembly ab oder legt diesen fest. |
ReferencedAssemblies |
Ruft die Assemblys ab, auf die durch das aktuelle Projekt verwiesen wird. |
TempFiles |
Ruft die Auflistung ab, die die temporären Dateien enthält, oder legt diese fest. |
TreatWarningsAsErrors |
Ruft einen Wert ab, der angibt, ob Warnungen als Fehler behandelt werden sollen, oder legt diesen fest. |
UserToken |
Ruft das Benutzertoken ab, das beim Erstellen des Compilerprozesses verwendet werden soll, oder legt dieses fest. |
WarningLevel |
Ruft die Warnstufe ab, bei der der Compiler die Kompilierung abbricht, oder legt diese fest. |
Win32Resource |
Ruft den Dateinamen einer Win32-Ressourcendatei ab, zu der in der kompilierten Assembly ein Link erstellt werden soll, oder legt diesen fest. |
Methoden
Equals(Object) |
Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object) |
GetHashCode() |
Fungiert als Standardhashfunktion. (Geerbt von Object) |
GetType() |
Ruft den Type der aktuellen Instanz ab. (Geerbt von Object) |
MemberwiseClone() |
Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object) |
ToString() |
Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object) |