GeneratorSupport Enumerazione

Definizione

Spazio dei nomi:

System.CodeDom.Compiler

Assembly:

System.CodeDom.dll

Pacchetto:

System.CodeDom v8.0.0

Source:

GeneratorSupport.cs

Definisce gli identificatori utilizzati per stabilire se un generatore di codice supporta determinati tipi di elementi di codice.

Questa enumerazione supporta una combinazione bit per bit dei rispettivi valori dei membri.

public enum class GeneratorSupport

[System.Flags]
public enum GeneratorSupport

[<System.Flags>]
type GeneratorSupport = 

Public Enum GeneratorSupport

Ereditarietà

Object

ValueType

Enum

GeneratorSupport

Attributi

FlagsAttribute

Campi

ArraysOfArrays	1	Indica che il generatore supporta le matrici di matrici.
AssemblyAttributes	4096	Indica che il generatore supporta gli attributi di assembly.
ChainedConstructorArguments	32768	Indica che il generatore supporta gli argomenti concatenati del costruttore.
ComplexExpressions	524288	Indica che il generatore supporta le espressioni complesse.
DeclareDelegates	512	Indica che il generatore supporta le dichiarazioni delegate.
DeclareEnums	256	Indica che il generatore supporta le dichiarazioni di enumerazione.
DeclareEvents	2048	Indica che il generatore supporta le dichiarazioni di evento.
DeclareIndexerProperties	33554432	Indica che il generatore supporta la dichiarazione di proprietà di indicizzatore.
DeclareInterfaces	1024	Indica che il generatore supporta le dichiarazioni di interfaccia.
DeclareValueTypes	128	Indica che il generatore supporta le dichiarazioni di tipi di valore.
EntryPointMethod	2	Indica che il generatore supporta una designazione del metodo del punto di ingresso del programma. Utilizzato nella compilazione di eseguibili.
GenericTypeDeclaration	16777216	Indica che il generatore supporta le dichiarazioni di tipi generici.
GenericTypeReference	8388608	Indica che il generatore supporta riferimenti a tipi generici.
GotoStatements	4	Indica che il generatore supporta le istruzioni goto.
MultidimensionalArrays	8	Indica che il generatore supporta il riferimento a matrici multidimensionali. Non è attualmente possibile utilizzare CodeDom per creare istanze di matrici multidimensionali.
MultipleInterfaceMembers	131072	Indica che il generatore supporta la dichiarazione di membri che implementano più interfacce.
NestedTypes	65536	Indica che il generatore supporta la dichiarazione di tipi annidati.
ParameterAttributes	8192	Indica che il generatore supporta gli attributi di parametro.
PartialTypes	4194304	Indica che il generatore supporta le dichiarazioni di tipi parziali.
PublicStaticMembers	262144	Indica che il generatore supporta membri statici pubblici.
ReferenceParameters	16384	Indica che il generatore supporta i parametri reference e out.
Resources	2097152	Indica che il generatore supporta la compilazione con le risorse .NET. che possono essere risorse predefinite compilate direttamente in un assembly oppure risorse a cui viene fatto riferimento in un assembly satellite.
ReturnTypeAttributes	64	Indica che il generatore supporta le dichiarazioni di attributi di tipi restituiti.
StaticConstructors	16	Indica che il generatore supporta i costruttori statici.
TryCatchStatements	32	Indica che il generatore supporta le istruzioni try-catch.
Win32Resources	1048576	Indica che il generatore supporta la compilazione con risorse Win32.

Esempio

Nell'esempio seguente viene illustrato l'uso CompilerParameters di per specificare varie impostazioni e opzioni del compilatore.

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

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

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

Commenti

Questi identificatori vengono usati quando si chiama il Supports metodo di un generatore di codice per determinare se il generatore di codice supporta la generazione di determinati tipi di codice.

Vedi anche

• ICodeGenerator
• Supports(GeneratorSupport)
• CompilerParameters