GeneratorSupport-Enumeration

Definiert Bezeichner, mit denen bestimmt wird, ob ein Code-Generator bestimmte Typen von Codeelementen unterstützt.

Diese Enumeration verfügt über ein FlagsAttribute -Attribut, das die bitweise Kombination der Memberwerte zulässt.

Namespace: System.CodeDom.Compiler
Assembly: System (in system.dll)

Syntax

'Declaration
<SerializableAttribute> _
<FlagsAttribute> _
Public Enumeration GeneratorSupport
'Usage
Dim instance As GeneratorSupport

[SerializableAttribute] 
[FlagsAttribute] 
public enum GeneratorSupport

[SerializableAttribute] 
[FlagsAttribute] 
public enum class GeneratorSupport

/** @attribute SerializableAttribute() */ 
/** @attribute FlagsAttribute() */ 
public enum GeneratorSupport

SerializableAttribute 
FlagsAttribute 
public enum GeneratorSupport

Member

	Membername	Beschreibung
	ArraysOfArrays	Gibt den Generator an, der Arrays von Arrays unterstützt.
	AssemblyAttributes	Gibt den Generator an, der Assemblyattribute unterstützt.
	ChainedConstructorArguments	Gibt den Generator an, der verkettete Konstruktorargumente unterstützt.
	ComplexExpressions	Gibt den Generator an, der komplexe Ausdrücke unterstützt.
	DeclareDelegates	Gibt den Generator an, der Delegatendeklarationen unterstützt.
	DeclareEnums	Gibt den Generator an, der Enumerationsdeklarationen unterstützt.
	DeclareEvents	Gibt den Generator an, der Ereignisdeklarationen unterstützt.
	DeclareIndexerProperties	Gibt den Generator an, der das Deklarieren von Indexereigenschaften unterstützt.
	DeclareInterfaces	Gibt den Generator an, der Schnittstellendeklarationen unterstützt.
	DeclareValueTypes	Gibt den Generator an, der Werttypdeklarationen unterstützt.
	EntryPointMethod	Gibt den Generator an, der das Bezeichnen einer Methode für den Programmeinstiegspunkt unterstützt. Dies wird beim Erstellen von ausführbaren Dateien verwendet.
	GenericTypeDeclaration	Gibt den Generator an, der generische Typdeklarationen unterstützt.
	GenericTypeReference	Gibt den Generator an, der generische Typverweise unterstützt.
	GotoStatements	Gibt den Generator an, der goto-Anweisungen unterstützt.
	MultidimensionalArrays	Gibt den Generator an, der Verweise auf mehrdimensionale Arrays unterstützt. Derzeit können mit CodeDom keine mehrdimensionalen Arrays instanziiert werden.
	MultipleInterfaceMembers	Gibt den Generator an, der das Deklarieren von Membern unterstützt, die mehrere Schnittstellen implementieren.
	NestedTypes	Gibt den Generator an, der das Deklarieren von geschachtelten Typen unterstützt.
	ParameterAttributes	Gibt den Generator an, der Parameterattribute unterstützt.
	PartialTypes	Gibt den Generator an, der partielle Typdeklarationen unterstützt.
	PublicStaticMembers	Gibt den Generator an, der öffentliche statische Member unterstützt.
	ReferenceParameters	Gibt den Generator an, der Verweis- und Out-Parameter unterstützt.
	Resources	Gibt an, dass der Generator die Kompilierung mit .NET Framework-Ressourcen unterstützt. Dabei kann es sich im Standardressourcen handeln, die direkt in eine Assembly kompiliert werden, oder um Ressourcen, auf die in einer Satellitenassembly verwiesen wird.
	ReturnTypeAttributes	Gibt den Generator an, der Attributdeklarationen von Rückgabetypen unterstützt.
	StaticConstructors	Gibt den Generator an, der statische Konstruktoren unterstützt.
	TryCatchStatements	Gibt den Generator an, der try...catch-Anweisungen unterstützt.
	Win32Resources	Gibt den Generator an, der die Kompilierung mit Win32-Ressourcen unterstützt.

Hinweise

Diese Bezeichner werden verwendet, wenn die Supports-Methode eines Code-Generators aufgerufen wird, um zu bestimmen, ob der Code-Generator das Generieren bestimmter Codetypen unterstützt.

Beispiel

Im folgenden Beispiel wird veranschaulicht, wie mithilfe von CompilerParameters verschiedene Compilereinstellungen und -optionen angegeben werden.

Public Shared Function CompileCode(provider As CodeDomProvider, _
    sourceFile As String, 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 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("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("nb-no.resources")
    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
   

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 (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("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("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;
    }
}

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 ( 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( "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( "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;
   }
}

Plattformen

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

Siehe auch

Referenz

System.CodeDom.Compiler-Namespace
ICodeGenerator
Supports
CompilerParameters-Klasse