GeneratorSupport Énumération

Définition

Définit les identificateurs utilisés pour déterminer si un générateur de code prend en charge certains types d'éléments de code.

Cette énumération prend en charge une combinaison au niveau du bit de ses valeurs membres.

public enum class GeneratorSupport
[System.Flags]
public enum GeneratorSupport
[System.Flags]
[System.Serializable]
public enum GeneratorSupport
[<System.Flags>]
type GeneratorSupport = 
[<System.Flags>]
[<System.Serializable>]
type GeneratorSupport = 
Public Enum GeneratorSupport
Héritage
GeneratorSupport
Attributs

Champs

ArraysOfArrays 1

Indique que le générateur prend en charge les tableaux de tableaux.

AssemblyAttributes 4096

Indique que le générateur prend en charge les attributs d'assembly.

ChainedConstructorArguments 32768

Indique que le générateur prend en charge les arguments chaînés du constructeur.

ComplexExpressions 524288

Indique que le générateur prend en charge les expressions complexes.

DeclareDelegates 512

Indique que le générateur prend en charge les déclarations delegate.

DeclareEnums 256

Indique que le générateur prend en charge les déclarations enumeration.

DeclareEvents 2048

Indique que le générateur prend en charge les déclarations event.

DeclareIndexerProperties 33554432

Indique que le générateur prend en charge la déclaration des propriétés d'indexeur.

DeclareInterfaces 1024

Indique que le générateur prend en charge les déclarations interface.

DeclareValueTypes 128

Indique que le générateur prend en charge les déclarations de type valeur.

EntryPointMethod 2

Indique que le générateur prend en charge une désignation de méthode de point d'entrée de programme, en vue de la génération d'exécutables.

GenericTypeDeclaration 16777216

Indique que le générateur prend en charge les déclarations de type générique.

GenericTypeReference 8388608

Indique que le générateur prend en charge les références de type générique.

GotoStatements 4

Indique que le générateur prend en charge les instructions Goto.

MultidimensionalArrays 8

Indique que le générateur prend en charge le référencement des tableaux multidimensionnels. Actuellement, CodeDom ne peut pas servir à instancier les tableaux multidimensionnels.

MultipleInterfaceMembers 131072

Indique que le générateur prend en charge la déclaration des membres implémentant plusieurs interfaces.

NestedTypes 65536

Indique que le générateur prend en charge la déclaration des types imbriqués.

ParameterAttributes 8192

Indique que le générateur prend en charge les attributs de paramètre.

PartialTypes 4194304

Indique que le générateur prend en charge les déclarations de type partiel.

PublicStaticMembers 262144

Indique que le générateur prend en charge les membres statiques publics.

ReferenceParameters 16384

Indique que le générateur prend en charge les paramètres de référence et les paramètres out.

Resources 2097152

Indique que le générateur prend en charge la compilation avec des ressources .NET. Il peut s'agir de ressources par défaut compilées directement dans un assembly ou de ressources référencées dans un assembly satellite.

ReturnTypeAttributes 64

Indique que le générateur prend en charge les déclarations attribute de types de retour.

StaticConstructors 16

Indique que le générateur prend en charge les constructeurs statiques.

TryCatchStatements 32

Indique que le générateur prend en charge les instructions try-catch.

Win32Resources 1048576

Indique que le générateur prend en charge la compilation à l'aide de ressources Win32.

Exemples

L’exemple suivant illustre l’utilisation CompilerParameters pour spécifier différents paramètres et options du compilateur.

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

Remarques

Ces identificateurs sont utilisés lors de l’appel de la Supports méthode d’un générateur de code pour déterminer si le générateur de code prend en charge la génération de certains types de code.

S’applique à

Voir aussi