GeneratorSupport Enumeración

Definición

Define los identificadores utilizados para determinar si un generador de código es compatible con ciertos tipos de elementos de código.Defines identifiers used to determine whether a code generator supports certain types of code elements.

Esta enumeración tiene el atributo FlagsAttribute, que permite una combinación bit a bit de sus valores de miembro.

public enum class GeneratorSupport
[System.Flags]
[System.Serializable]
public enum GeneratorSupport
type GeneratorSupport = 
Public Enum GeneratorSupport
Herencia
GeneratorSupport
Atributos

Campos

ArraysOfArrays 1

Indica si el generador es compatible con matrices de matrices.Indicates the generator supports arrays of arrays.

AssemblyAttributes 4096

Indica si el generador es compatible con atributos de ensamblados.Indicates the generator supports assembly attributes.

ChainedConstructorArguments 32768

Indica si el generador es compatible con los argumentos constructores encadenados.Indicates the generator supports chained constructor arguments.

ComplexExpressions 524288

Indica si el generador es compatible con expresiones complejas.Indicates the generator supports complex expressions.

DeclareDelegates 512

Indica si el generador es compatible con declaraciones de delegados.Indicates the generator supports delegate declarations.

DeclareEnums 256

Indica si el generador es compatible con declaraciones de enumeración.Indicates the generator supports enumeration declarations.

DeclareEvents 2048

Indica si el generador es compatible con declaraciones de eventos.Indicates the generator supports event declarations.

DeclareIndexerProperties 33554432

Indica si el generador es compatible con la declaración de propiedades del indizador.Indicates the generator supports the declaration of indexer properties.

DeclareInterfaces 1024

Indica si el generador es compatible con declaraciones de interfaz.Indicates the generator supports interface declarations.

DeclareValueTypes 128

Indica si el generador es compatible con declaraciones de tipos de valor.Indicates the generator supports value type declarations.

EntryPointMethod 2

Indica si el generador es compatible con una designación de método de punto de entrada de programa.Indicates the generator supports a program entry point method designation. Se utiliza cuando se compilan los ejecutables.This is used when building executables.

GenericTypeDeclaration 16777216

Indica si el generador es compatible con declaraciones de tipos genéricos.Indicates the generator supports generic type declarations.

GenericTypeReference 8388608

Indica si el generador es compatible con referencias de tipos genéricos.Indicates the generator supports generic type references.

GotoStatements 4

Indica si el generador es compatible con instrucciones goto.Indicates the generator supports goto statements.

MultidimensionalArrays 8

Indica si el generador es compatible con matrices multidimensionales de referencia.Indicates the generator supports referencing multidimensional arrays. Actualmente, no se puede utilizar CodeDom para crear una instancia de matrices multidimensionales.Currently, the CodeDom cannot be used to instantiate multidimensional arrays.

MultipleInterfaceMembers 131072

Indica si el generador es compatible con la declaración de miembros que implementan múltiples interfaces.Indicates the generator supports the declaration of members that implement multiple interfaces.

NestedTypes 65536

Indica si el generador es compatible con la declaración de tipos anidados.Indicates the generator supports the declaration of nested types.

ParameterAttributes 8192

Indica si el generador es compatible con atributos de parámetros.Indicates the generator supports parameter attributes.

PartialTypes 4194304

Indica si el generador es compatible con declaraciones de tipos genéricos.Indicates the generator supports partial type declarations.

PublicStaticMembers 262144

Indica si el generador es compatible con miembros estáticos públicos.Indicates the generator supports public static members.

ReferenceParameters 16384

Indica si el generador es compatible con parámetros de referencia y de salida.Indicates the generator supports reference and out parameters.

Resources 2097152

Indica si el generador admite la compilación con recursos de .NET Framework.Indicates the generator supports compilation with .NET Framework resources. Éstos pueden ser recursos predeterminados compilados directamente en un ensamblado o recursos a los que se hace referencia en un ensamblado satélite.These can be default resources compiled directly into an assembly, or resources referenced in a satellite assembly.

ReturnTypeAttributes 64

Indica si el generador es compatible con declaraciones de atributos de tipo de valor devuelto.Indicates the generator supports return type attribute declarations.

StaticConstructors 16

Indica si el generador es compatible con constructores estáticos.Indicates the generator supports static constructors.

TryCatchStatements 32

Indica si el generador es compatible con instrucciones try...catch.Indicates the generator supports try...catch statements.

Win32Resources 1048576

Indica si el generador es compatible con la compilación de recursos Win32.Indicates the generator supports compilation with Win32 resources.

Ejemplos

En el siguiente ejemplo se muestra CompilerParameters el uso de para especificar varias opciones y configuraciones del compilador.The following example illustrates using CompilerParameters to specify various compiler settings and options.

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

Comentarios

Estos identificadores se usan cuando se llama Supports al método de un generador de código para determinar si el generador de código admite la generación de determinados tipos de código.These identifiers are used when calling the Supports method of a code generator to determine whether the code generator supports generating certain types of code.

Se aplica a

Consulte también: