LocalBuilder.LocalType-Eigenschaft

Ruft den Typ der lokalen Variablen ab.

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

Syntax

'Declaration
Public Overrides ReadOnly Property LocalType As Type
'Usage
Dim instance As LocalBuilder
Dim value As Type

value = instance.LocalType

public override Type LocalType { get; }

public:
virtual property Type^ LocalType {
    Type^ get () override;
}

/** @property */
public Type get_LocalType ()

public override function get LocalType () : Type

Eigenschaftenwert

Der Type der lokalen Variablen.

Beispiel

Im folgenden Codebeispiel wird die Verwendung von LocalType veranschaulicht. Dieser Code ist Teil eines umfangreicheren Beispiels für die LocalBuilder-Klasse.

' Create an assembly.
Dim myAssemblyName As New AssemblyName()
myAssemblyName.Name = "SampleAssembly"

Dim myAssembly As AssemblyBuilder = Thread.GetDomain().DefineDynamicAssembly _
                                       (myAssemblyName, AssemblyBuilderAccess.Run)

' Create a module 'myModule'.
Dim myModule As ModuleBuilder = myAssembly.DefineDynamicModule("SampleModule", True)

' Define a public class 'myClass'.
Dim myTypeBuilder As TypeBuilder = myModule.DefineType("myClass", TypeAttributes.Public)

' Define a private String field.
Dim myField As FieldBuilder = myTypeBuilder.DefineField("myMessage", GetType(String), _
                                                               FieldAttributes.Private)

' Create the constructor.
Dim myConstructorArgs As Type() = {GetType(String)}
Dim myConstructor As ConstructorBuilder = myTypeBuilder.DefineConstructor _
                  (MethodAttributes.Public, CallingConventions.Standard, myConstructorArgs)

' Generate IL for the method.
Dim myConstructorIL As ILGenerator = myConstructor.GetILGenerator()
myConstructorIL.Emit(OpCodes.Ldarg_0)
Dim mySuperConstructor As ConstructorInfo = GetType(Object).GetConstructor(New Type() {})
myConstructorIL.Emit(OpCodes.Call, mySuperConstructor)
myConstructorIL.Emit(OpCodes.Ldarg_0)
myConstructorIL.Emit(OpCodes.Ldarg_1)
myConstructorIL.Emit(OpCodes.Stfld, myField)
myConstructorIL.Emit(OpCodes.Ret)

' Create the 'Function1' public method.
Dim myMethod As MethodBuilder = myTypeBuilder.DefineMethod("Function1", MethodAttributes. _
                                          Public, GetType(String), Nothing)

' Generate IL for 'Function1'.
Dim myMethodIL As ILGenerator = myMethod.GetILGenerator()

' Create local variables.
Dim myLB1 As LocalBuilder = myMethodIL.DeclareLocal(GetType(String))
myLB1.SetLocalSymInfo("myString")
Console.WriteLine("'myLB1' type is :{0}", myLB1.LocalType)
Dim myLB2 As LocalBuilder = myMethodIL.DeclareLocal(GetType(Integer))
myLB2.SetLocalSymInfo("myInt", 1, 2)
Console.WriteLine("'myLB2' type is :{0}", myLB2.LocalType)

myMethodIL.Emit(OpCodes.Ldstr, "Local value"  )
myMethodIL.Emit(OpCodes.Stloc_0 )
myMethodIL.Emit(OpCodes.Ldloc_0 )
myMethodIL.Emit(OpCodes.Stloc_1)
myMethodIL.Emit(OpCodes.Ldloc_1 )
myMethodIL.Emit(OpCodes.Ret )

' Create "myClass" class.
Dim myType1 As Type = myTypeBuilder.CreateType()

Console.WriteLine("'myClass' is created.")

// Create an assembly.
AssemblyName myAssemblyName = new AssemblyName();
myAssemblyName.Name = "SampleAssembly";

AssemblyBuilder myAssembly = Thread.GetDomain().DefineDynamicAssembly(
   myAssemblyName, AssemblyBuilderAccess.Run);

// Create a module 'myModule'.
ModuleBuilder myModule=myAssembly.DefineDynamicModule("SampleModule",true);

// Define a public class 'myClass'.
TypeBuilder myTypeBuilder = myModule.DefineType("myClass", TypeAttributes.Public);

// Define a private String field.
FieldBuilder myField = myTypeBuilder.DefineField("myMessage", typeof(String), FieldAttributes.Private);

// Create the constructor.
Type[] myConstructorArgs = { typeof(String) };
ConstructorBuilder myConstructor = myTypeBuilder.DefineConstructor(
   MethodAttributes.Public, CallingConventions.Standard, myConstructorArgs);

// Generate IL for the method.
ILGenerator myConstructorIL = myConstructor.GetILGenerator();
myConstructorIL.Emit(OpCodes.Ldarg_0);
ConstructorInfo mySuperConstructor = typeof(Object).GetConstructor(new Type[0]);
myConstructorIL.Emit(OpCodes.Call, mySuperConstructor);
myConstructorIL.Emit(OpCodes.Ldarg_0);
myConstructorIL.Emit(OpCodes.Ldarg_1);
myConstructorIL.Emit(OpCodes.Stfld, myField);
myConstructorIL.Emit(OpCodes.Ret);

// Create the 'Function1' public method.
MethodBuilder myMethod = myTypeBuilder.DefineMethod("Function1",
   MethodAttributes.Public, typeof(String), null);

// Generate IL for 'Function1'.
ILGenerator myMethodIL = myMethod.GetILGenerator();

// Create local variables.
LocalBuilder myLB1 = myMethodIL.DeclareLocal(typeof(string));
myLB1.SetLocalSymInfo("myString");
Console.WriteLine("'myLB1' type is :{0}", myLB1.LocalType);
LocalBuilder myLB2 = myMethodIL.DeclareLocal(typeof(int));
myLB2.SetLocalSymInfo("myInt",1,2);
Console.WriteLine("'myLB2' type is :{0}", myLB2.LocalType);
myMethodIL.Emit(OpCodes.Ldstr, "Local value"  );
myMethodIL.Emit(OpCodes.Stloc_0 );
myMethodIL.Emit(OpCodes.Ldloc_0 );
myMethodIL.Emit(OpCodes.Stloc_1);
myMethodIL.Emit(OpCodes.Ldloc_1 );
myMethodIL.Emit(OpCodes.Ret );

// Create "myClass" class.
Type myType1 = myTypeBuilder.CreateType();



Console.WriteLine("'myClass' is created.");

// Create an assembly.
AssemblyName^ myAssemblyName = gcnew AssemblyName;
myAssemblyName->Name = "SampleAssembly";
AssemblyBuilder^ myAssembly = Thread::GetDomain()->DefineDynamicAssembly( myAssemblyName, AssemblyBuilderAccess::Run );

// Create a module 'myModule'.
ModuleBuilder^ myModule = myAssembly->DefineDynamicModule( "SampleModule", true );

// Define a public class 'myClass'.
TypeBuilder^ myTypeBuilder = myModule->DefineType( "myClass", TypeAttributes::Public );

// Define a private String field.
FieldBuilder^ myField = myTypeBuilder->DefineField( "myMessage", String::typeid, FieldAttributes::Private );

// Create the constructor.
array<Type^>^myConstructorArgs = {String::typeid};
ConstructorBuilder^ myConstructor = myTypeBuilder->DefineConstructor( MethodAttributes::Public, CallingConventions::Standard, myConstructorArgs );

// Generate IL for the method.
ILGenerator^ myConstructorIL = myConstructor->GetILGenerator();
myConstructorIL->Emit( OpCodes::Ldarg_0 );
ConstructorInfo^ mySuperConstructor = Object::typeid->GetConstructor( gcnew array<Type^>(0) );
myConstructorIL->Emit( OpCodes::Call, mySuperConstructor );
myConstructorIL->Emit( OpCodes::Ldarg_0 );
myConstructorIL->Emit( OpCodes::Ldarg_1 );
myConstructorIL->Emit( OpCodes::Stfld, myField );
myConstructorIL->Emit( OpCodes::Ret );

// Create the 'Function1' public method.
MethodBuilder^ myMethod = myTypeBuilder->DefineMethod( "Function1", MethodAttributes::Public, String::typeid, nullptr );

// Generate IL for 'Function1'.
ILGenerator^ myMethodIL = myMethod->GetILGenerator();

// Create local variables.
LocalBuilder^ myLB1 = myMethodIL->DeclareLocal( String::typeid );
myLB1->SetLocalSymInfo( "myString" );
Console::WriteLine( "'myLB1' type is :{0}", myLB1->LocalType );
LocalBuilder^ myLB2 = myMethodIL->DeclareLocal( int::typeid );
myLB2->SetLocalSymInfo( "myInt", 1, 2 );
Console::WriteLine( "'myLB2' type is :{0}", myLB2->LocalType );
myMethodIL->Emit( OpCodes::Ldstr, "Local value" );
myMethodIL->Emit( OpCodes::Stloc_0 );
myMethodIL->Emit( OpCodes::Ldloc_0 );
myMethodIL->Emit( OpCodes::Stloc_1 );
myMethodIL->Emit( OpCodes::Ldloc_1 );
myMethodIL->Emit( OpCodes::Ret );

// Create "myClass" class.
Type^ myType1 = myTypeBuilder->CreateType();
Console::WriteLine( "'myClass' is created." );

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

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