Condividi tramite


ModuleBuilder.DefineEnum(String, TypeAttributes, Type) Metodo

Definizione

Definisce un tipo di enumerazione, ovvero un tipo di valore con un solo campo non statico denominato value__ del tipo specificato.

public:
 System::Reflection::Emit::EnumBuilder ^ DefineEnum(System::String ^ name, System::Reflection::TypeAttributes visibility, Type ^ underlyingType);
public System.Reflection.Emit.EnumBuilder DefineEnum (string name, System.Reflection.TypeAttributes visibility, Type underlyingType);
member this.DefineEnum : string * System.Reflection.TypeAttributes * Type -> System.Reflection.Emit.EnumBuilder
Public Function DefineEnum (name As String, visibility As TypeAttributes, underlyingType As Type) As EnumBuilder

Parametri

name
String

Percorso completo del tipo di enumerazione. name non può contenere valori Null incorporati.

visibility
TypeAttributes

Attributi del tipo per l'enumerazione. Gli attributi sono definiti per singolo bit dal campo VisibilityMask.

underlyingType
Type

Tipo sottostante per l'enumerazione. Deve essere un tipo Integer incorporato.

Restituisce

Enumerazione definita.

Eccezioni

Sono forniti gli attributi che non siano di visibilità.

-oppure-

Nell'assembly padre del modulo è presente un'enumerazione con il nome indicato.

-oppure-

Gli attributi di visibilità non corrispondono all'ambito dell'enumerazione. Ad esempio, NestedPublic viene specificato per visibility, ma l'enumerazione non è un tipo annidato.

name è null.

Esempio

Nell'esempio seguente viene illustrato l'uso di per implementare una classe di DefineEnum enumerazione in un modulo dinamico. L'esempio definisce un'enumerazione denominata Elevation con un tipo sottostante di Int32e crea due elementi: Low, con un valore pari a 0 e High, con un valore pari a 1. Dopo aver creato il tipo, l'assembly viene salvato con il nome TempAssembly.dll. È possibile utilizzare il Ildasm.exe (Disassembler IL) per esaminare il contenuto di questo assembly.

Nota

Prima di .NET Framework versione 2.0, questo esempio di codice non produce un'enumerazione corretta.

using namespace System;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

void main()
{
    // Get the current application domain for the current thread.
    AppDomain^ currentDomain = AppDomain::CurrentDomain;
      
    // Create a dynamic assembly in the current application domain, 
    // and allow it to be executed and saved to disk.
    AssemblyName^ aName = gcnew AssemblyName("TempAssembly");
    AssemblyBuilder^ ab = currentDomain->DefineDynamicAssembly( 
            aName, AssemblyBuilderAccess::RunAndSave);
      
    // Define a dynamic module in "TempAssembly" assembly. For a single-
    // module assembly, the module has the same name as the assembly.
    ModuleBuilder^ mb = 
            ab->DefineDynamicModule(aName->Name, aName->Name + ".dll");
      
    // Define a public enumeration with the name "Elevation" and an 
    // underlying type of Int32.
    EnumBuilder^ eb = 
            mb->DefineEnum("Elevation", TypeAttributes::Public, int::typeid);
      
    // Define two members, "High" and "Low".
    eb->DefineLiteral("Low", (Object^) 0);
    eb->DefineLiteral("High", 1);

    // Create the type and save the assembly.
    Type^ finished = eb->CreateType();
    ab->Save(aName->Name + ".dll");

    for each (Object^ o in Enum::GetValues(finished))
    {
        Console::WriteLine("{0}.{1} = {2}", finished, o, (int)o);
    }
}

/* This code example produces the following output:

Elevation.Low = 0
Elevation.High = 1
 */
using System;
using System.Reflection;
using System.Reflection.Emit;

class Example
{
    public static void Main()
    {
        // Get the current application domain for the current thread.
        AppDomain currentDomain = AppDomain.CurrentDomain;

        // Create a dynamic assembly in the current application domain,
        // and allow it to be executed and saved to disk.
        AssemblyName aName = new AssemblyName("TempAssembly");
        AssemblyBuilder ab = currentDomain.DefineDynamicAssembly(
            aName, AssemblyBuilderAccess.RunAndSave);

        // Define a dynamic module in "TempAssembly" assembly. For a single-
        // module assembly, the module has the same name as the assembly.
        ModuleBuilder mb = ab.DefineDynamicModule(aName.Name, aName.Name + ".dll");

        // Define a public enumeration with the name "Elevation" and an
        // underlying type of Integer.
        EnumBuilder eb = mb.DefineEnum("Elevation", TypeAttributes.Public, typeof(int));

        // Define two members, "High" and "Low".
        eb.DefineLiteral("Low", 0);
        eb.DefineLiteral("High", 1);

        // Create the type and save the assembly.
        Type finished = eb.CreateType();
        ab.Save(aName.Name + ".dll");

        foreach( object o in Enum.GetValues(finished) )
        {
            Console.WriteLine("{0}.{1} = {2}", finished, o, ((int) o));
        }
    }
}

/* This code example produces the following output:

Elevation.Low = 0
Elevation.High = 1
 */
Imports System.Reflection
Imports System.Reflection.Emit

Module Example
   
    Sub Main()
      
        ' Get the current application domain for the current thread.
        Dim currentDomain As AppDomain = AppDomain.CurrentDomain
      
        ' Create a dynamic assembly in the current application domain, 
        ' and allow it to be executed and saved to disk.
        Dim aName As AssemblyName = New AssemblyName("TempAssembly")
        Dim ab As AssemblyBuilder = currentDomain.DefineDynamicAssembly( _ 
            aName, AssemblyBuilderAccess.RunAndSave)
      
        ' Define a dynamic module in "TempAssembly" assembly. For a single-
        ' module assembly, the module has the same name as the assembly.
        Dim mb As ModuleBuilder = _
            ab.DefineDynamicModule(aName.Name, aName.Name & ".dll")
      
        ' Define a public enumeration with the name "Elevation" and an 
        ' underlying type of Integer.
        Dim eb As EnumBuilder = _
            mb.DefineEnum("Elevation", TypeAttributes.Public, GetType(Integer))
      
        ' Define two members, "High" and "Low".
        eb.DefineLiteral("Low", 0)
        eb.DefineLiteral("High", 1)

        ' Create the type and save the assembly.
        Dim finished As Type = eb.CreateType()
        ab.Save(aName.Name & ".dll")

        For Each o As Object In [Enum].GetValues(finished)
            Console.WriteLine("{0}.{1} = {2}", finished, o, CInt(o))
        Next
   End Sub
End Module

' This code example produces the following output:
'
'Elevation.Low = 0
'Elevation.High = 1

Commenti

L'enumerazione definita è una classe derivata di Enum. Il value__ campo dispone di Private attributi e SpecialName impostati.

Per altre informazioni sui tipi integer predefiniti che possono essere specificati come tipi sottostanti di enumerazioni, vedere Panoramica della libreria di classi.

Nota

In .NET Framework versioni 1.0 e 1.1, è necessario definire le enumerazioni usando TypeBuilder perché EnumBuilder genera enumerazioni i cui elementi sono di tipo Int32 anziché il tipo di enumerazione. In .NET Framework versione 2.0 genera EnumBuilder enumerazioni i cui elementi hanno il tipo corretto.

Nota

A partire da .NET Framework 2.0 Service Pack 1, questo membro non richiede ReflectionPermission più con il ReflectionPermissionFlag.ReflectionEmit flag . Vedere Problemi di sicurezza in Reflection Emit. Per usare questa funzionalità, l'applicazione deve avere come destinazione .NET Framework 3.5 o versione successiva.

Si applica a