ILGenerator.DeclareLocal メソッドとは？ わかりやすく解説

Public Overridable Function
 DeclareLocal ( _
    localType As Type, _
    pinned As Boolean _
) As LocalBuilder

Dim instance As ILGenerator
Dim localType As Type
Dim pinned As Boolean
Dim returnValue As LocalBuilder

returnValue = instance.DeclareLocal(localType, pinned)

public virtual LocalBuilder DeclareLocal (
    Type localType,
    bool pinned
)

public:
virtual LocalBuilder^ DeclareLocal (
    Type^ localType, 
    bool pinned
)

public LocalBuilder DeclareLocal (
    Type localType, 
    boolean pinned
)

public function DeclareLocal (
    localType : Type, 
    pinned : boolean
) : LocalBuilder

Public Overridable Function
 DeclareLocal ( _
    localType As Type _
) As LocalBuilder

Dim instance As ILGenerator
Dim localType As Type
Dim returnValue As LocalBuilder

returnValue = instance.DeclareLocal(localType)

public virtual LocalBuilder DeclareLocal (
    Type localType
)

public:
virtual LocalBuilder^ DeclareLocal (
    Type^ localType
)

public LocalBuilder DeclareLocal (
    Type localType
)

public function DeclareLocal (
    localType : Type
) : LocalBuilder

' 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." );