EnumBuilder.GUID-Eigenschaft

Gibt die GUID dieser Enumeration zurück.

Namespace: System.Reflection.Emit
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
Public Overrides ReadOnly Property GUID As Guid
'Usage
Dim instance As EnumBuilder
Dim value As Guid

value = instance.GUID

public override Guid GUID { get; }

public:
virtual property Guid GUID {
    Guid get () override;
}

/** @property */
public Guid get_GUID ()

public override function get GUID () : Guid

Eigenschaftenwert

Schreibgeschützt. Die GUID dieser Enumeration.

Ausnahmen

Ausnahmetyp	Bedingung
NotSupportedException	Diese Methode wird bei unvollständigen Typen derzeit nicht unterstützt.

Beispiel

Das folgende Codebeispiel veranschaulicht die Verwendung der GUID-Eigenschaft zum Verweisen auf die zugeordnete Guid des aktuellen EnumBuilder.

Imports System
Imports System.Collections
Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit

Public Class MyEnumBuilderSample
   Private Shared myAssemblyBuilder As AssemblyBuilder
   Private Shared myModuleBuilder As ModuleBuilder
   Private Shared myEnumBuilder As EnumBuilder
   
   
   Public Shared Sub Main()
      Try
         CreateCallee(Thread.GetDomain(), AssemblyBuilderAccess.Save)
         Dim myTypeArray As Type() = myModuleBuilder.GetTypes()
         Dim myType As Type
         For Each myType In  myTypeArray
            Console.WriteLine("Enum Builder defined in the module builder is: " + myType.Name)
         Next myType
         
         Console.WriteLine("Enum TypeToken is :" + myEnumBuilder.TypeToken.ToString())
         Console.WriteLine("Enum UnderLyingField is :" + myEnumBuilder.UnderlyingField.ToString())
         Console.WriteLine("Enum UnderLyingSystemType is :" + myEnumBuilder.UnderlyingSystemType.ToString())
         Console.WriteLine("Enum GUID is :" + myEnumBuilder.GUID.ToString())
         myAssemblyBuilder.Save("EmittedAssembly.dll")
      Catch ex As NotSupportedException
         Console.WriteLine("The following is the exception is raised: " + ex.Message)
      Catch e As Exception
         Console.WriteLine("The following is the exception raised: " + e.Message)
      End Try
   End Sub 'Main
   
   
   Private Shared Sub CreateCallee(myAppDomain As AppDomain, access As AssemblyBuilderAccess)
      ' Create a name for the assembly.
      Dim myAssemblyName As New AssemblyName()
      myAssemblyName.Name = "EmittedAssembly"
      
      ' Create the dynamic assembly.
      myAssemblyBuilder = myAppDomain.DefineDynamicAssembly(myAssemblyName, _
                 AssemblyBuilderAccess.Save)
      ' Create a dynamic module.
      myModuleBuilder = myAssemblyBuilder.DefineDynamicModule("EmittedModule", "EmittedModule.mod")
      ' Create a dynamic Enum.
      myEnumBuilder = myModuleBuilder.DefineEnum("MyNamespace.MyEnum", _
                 TypeAttributes.Public, GetType(Int32))
      
      Dim myFieldBuilder1 As FieldBuilder = myEnumBuilder.DefineLiteral("FieldOne", 1)
      Dim myFieldBuilder2 As FieldBuilder = myEnumBuilder.DefineLiteral("FieldTwo", 2)
      
      myEnumBuilder.CreateType()
   End Sub 'CreateCallee
End Class 'MyEnumBuilderSample

using System;
using System.Collections;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;

public class MyEnumBuilderSample
{
   static AssemblyBuilder myAssemblyBuilder;
   static ModuleBuilder myModuleBuilder;
   static EnumBuilder myEnumBuilder;
   
   public static void Main()
   {
      try
      {
         CreateCallee(Thread.GetDomain(), AssemblyBuilderAccess.Save);
         Type[] myTypeArray = myModuleBuilder.GetTypes();
         foreach(Type myType in myTypeArray)
         {
            Console.WriteLine("Enum Builder defined in the module builder is: " 
               + myType.Name);
         }

         Console.WriteLine("Enum TypeToken is :" +  
                                       myEnumBuilder.TypeToken.ToString());
         Console.WriteLine("Enum UnderLyingField is :" +  
                                    myEnumBuilder.UnderlyingField.ToString());
         Console.WriteLine("Enum UnderLyingSystemType is :" +  
                              myEnumBuilder.UnderlyingSystemType.ToString());
         Console.WriteLine("Enum GUID is :" + myEnumBuilder.GUID.ToString());
         myAssemblyBuilder.Save("EmittedAssembly.dll");
      }
      catch(NotSupportedException ex)
      {
         Console.WriteLine("The following is the exception is raised: " + ex.Message);
      }
      catch(Exception e)
      {
         Console.WriteLine("The following is the exception raised: " + e.Message);
      }
   }

   private static void CreateCallee(AppDomain myAppDomain, AssemblyBuilderAccess access)
   {
      // Create a name for the assembly.
      AssemblyName myAssemblyName = new AssemblyName();
      myAssemblyName.Name = "EmittedAssembly";

      // Create the dynamic assembly.
      myAssemblyBuilder = myAppDomain.DefineDynamicAssembly(myAssemblyName, 
                                             AssemblyBuilderAccess.Save);
      // Create a dynamic module.
      myModuleBuilder = myAssemblyBuilder.DefineDynamicModule("EmittedModule", 
                                                         "EmittedModule.mod");
      // Create a dynamic Enum.
      myEnumBuilder = myModuleBuilder.DefineEnum("MyNamespace.MyEnum", 
                                 TypeAttributes.Public, typeof(Int32));

      FieldBuilder myFieldBuilder1 = myEnumBuilder.DefineLiteral("FieldOne", 1);
      FieldBuilder myFieldBuilder2 = myEnumBuilder.DefineLiteral("FieldTwo", 2);

      myEnumBuilder.CreateType();
   }
}

using namespace System;
using namespace System::Collections;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
public ref class MyEnumBuilderSample
{
private:
   static AssemblyBuilder^ myAssemblyBuilder;
   static ModuleBuilder^ myModuleBuilder;
   static EnumBuilder^ myEnumBuilder;

public:
   static void Main()
   {
      try
      {
         CreateCallee( Thread::GetDomain(), AssemblyBuilderAccess::Save );
         array<Type^>^myTypeArray = myModuleBuilder->GetTypes();
         IEnumerator^ myEnum = myTypeArray->GetEnumerator();
         while ( myEnum->MoveNext() )
         {
            Type^ myType = safe_cast<Type^>(myEnum->Current);
            Console::WriteLine( "Enum Builder defined in the module builder is: {0}", myType->Name );
         }
         Console::WriteLine( "Enum TypeToken is :{0}", myEnumBuilder->TypeToken );
         Console::WriteLine( "Enum UnderLyingField is :{0}", myEnumBuilder->UnderlyingField );
         Console::WriteLine( "Enum UnderLyingSystemType is :{0}", myEnumBuilder->UnderlyingSystemType );
         Console::WriteLine( "Enum GUID is :{0}", myEnumBuilder->GUID );
         myAssemblyBuilder->Save( "EmittedAssembly.dll" );
      }
      catch ( NotSupportedException^ ex ) 
      {
         Console::WriteLine( "The following is the exception is raised: {0}", ex->Message );
      }
      catch ( Exception^ e ) 
      {
         Console::WriteLine( "The following is the exception raised: {0}", e->Message );
      }
   }


private:
   static void CreateCallee( AppDomain^ myAppDomain, AssemblyBuilderAccess /*access*/ )
   {
      // Create a name for the assembly.
      AssemblyName^ myAssemblyName = gcnew AssemblyName;
      myAssemblyName->Name = "EmittedAssembly";

      // Create the dynamic assembly.
      myAssemblyBuilder = myAppDomain->DefineDynamicAssembly( myAssemblyName, AssemblyBuilderAccess::Save );

      // Create a dynamic module.
      myModuleBuilder = myAssemblyBuilder->DefineDynamicModule( "EmittedModule", "EmittedModule.mod" );

      // Create a dynamic Enum.
      myEnumBuilder = myModuleBuilder->DefineEnum( "MyNamespace.MyEnum", TypeAttributes::Public, Int32::typeid );
      FieldBuilder^ myFieldBuilder1 = myEnumBuilder->DefineLiteral( "FieldOne", 1 );
      FieldBuilder^ myFieldBuilder2 = myEnumBuilder->DefineLiteral( "FieldTwo", 2 );
      myEnumBuilder->CreateType();
   }
};

int main()
{
   MyEnumBuilderSample::Main();
}

import System.*;
import System.Collections.*;
import System.Threading.*;
import System.Reflection.*;
import System.Reflection.Emit.*;

public class MyEnumBuilderSample
{
    private static AssemblyBuilder myAssemblyBuilder;
    private static ModuleBuilder myModuleBuilder;
    private static EnumBuilder myEnumBuilder;

    public static void main(String[] args)
    {
        try {
            CreateCallee(System.Threading.Thread.GetDomain(), 
                AssemblyBuilderAccess.Save);

            Type myTypeArray[] = myModuleBuilder.GetTypes();
            Type myType = null;
            for (int iCtr = 0; iCtr < myTypeArray.length;iCtr++ ) {
                myType = myTypeArray[iCtr];
                Console.WriteLine("Enum Builder defined in the module "
                    + "builder is: " + myType.get_Name());
            }
            Console.WriteLine("Enum TypeToken is :" 
                + myEnumBuilder.get_TypeToken().ToString());
            Console.WriteLine("Enum UnderLyingField is :" 
                + myEnumBuilder.get_UnderlyingField().ToString());
            Console.WriteLine("Enum UnderLyingSystemType is :"
                + myEnumBuilder.get_UnderlyingSystemType().ToString());
            Console.WriteLine("Enum GUID is :" 
                + myEnumBuilder.get_GUID().ToString());
            myAssemblyBuilder.Save("EmittedAssembly.dll");
        }
        catch (NotSupportedException ex) {
            Console.WriteLine("The following is the exception is raised: " 
                + ex.get_Message());
        }
        catch (System.Exception e) {
            Console.WriteLine("The following is the exception raised: " 
                + e.get_Message());
        }
    } //main

    private static void CreateCallee(AppDomain myAppDomain, 
        AssemblyBuilderAccess access)
    {
        // Create a name for the assembly.
        AssemblyName myAssemblyName = new AssemblyName();
        myAssemblyName.set_Name("EmittedAssembly");

        // Create the dynamic assembly.
        myAssemblyBuilder = myAppDomain.DefineDynamicAssembly(myAssemblyName, 
            AssemblyBuilderAccess.Save);

        // Create a dynamic module.
        myModuleBuilder = myAssemblyBuilder.
            DefineDynamicModule("EmittedModule", "EmittedModule.mod");

        // Create a dynamic Enum.
        myEnumBuilder = myModuleBuilder.DefineEnum("MyNamespace.MyEnum", 
            TypeAttributes.Public, Int32.class.ToType());

        FieldBuilder myFieldBuilder1 = myEnumBuilder.DefineLiteral("FieldOne",
            (Int32)1);
        FieldBuilder myFieldBuilder2 = myEnumBuilder.DefineLiteral("FieldTwo",
            (Int32)2);
        myEnumBuilder.CreateType();
    } //CreateCallee
} //MyEnumBuilderSample

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

EnumBuilder-Klasse
EnumBuilder-Member
System.Reflection.Emit-Namespace