次の方法で共有


ILGenerator.EndScope メソッド

構文のスコープを終了します。

Public Overridable Sub EndScope()
[C#]
public virtual void EndScope();
[C++]
public: virtual void EndScope();
[JScript]
public function EndScope();

解説

このメソッドを使用して、シンボリック情報を作成します。 BeginScope と共に使用されます。

次のコード例は、 BeginScope および EndScope の使用方法を示しています。

 
' Get the current AppDomain.
Dim myAppDomain As AppDomain = AppDomain.CurrentDomain
Dim myAssemblyName As New AssemblyName()
myAssemblyName.Name = "SampleAssembly"

' Create a dynamic assembly 'myAssembly' with access mode 'Run'.
Dim myAssembly As AssemblyBuilder = myAppDomain.DefineDynamicAssembly(myAssemblyName, _
                                                            AssemblyBuilderAccess.Run)
' Create a dynamic module 'myModule' in 'myAssembly'.
Dim myModule As ModuleBuilder = myAssembly.DefineDynamicModule("MyDynamicModule", True)
' Define a public class 'MyDynamicClass'.
Dim myTypeBuilder As TypeBuilder = myModule.DefineType("MyDynamicClass", _
                                                               TypeAttributes.Public)
' Define a public string field.
Dim myField As FieldBuilder = myTypeBuilder.DefineField("MyDynamicField", GetType(String), _
                                                               FieldAttributes.Public)
' Create the constructor.
Dim myConstructorArgs As Type() = {GetType(String)}
Dim myConstructor As ConstructorBuilder = myTypeBuilder.DefineConstructor _
               (MethodAttributes.Public, CallingConventions.Standard, myConstructorArgs)

' Generate IL for 'myConstructor'.
Dim myConstructorIL As ILGenerator = myConstructor.GetILGenerator()
' Emit the necessary opcodes.
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)

' Define a dynamic method named 'MyDynamicMethod'.
Dim myMethod As MethodBuilder = myTypeBuilder.DefineMethod("MyDynamicMethod", _
                        MethodAttributes.Public, GetType(String), Nothing)
' Generate IL for 'myMethod'.
Dim myMethodIL As ILGenerator = myMethod.GetILGenerator()

' Begin the scope for a local variable.
myMethodIL.BeginScope()

Dim myLocalBuilder As LocalBuilder = myMethodIL.DeclareLocal(GetType(Integer))
Console.WriteLine(ControlChars.NewLine + "Trying to access the local variable within" + _
                                                                     " the scope.")
Console.WriteLine("'myLocalBuilder' type is :{0}", myLocalBuilder.LocalType)
myMethodIL.Emit(OpCodes.Ldstr, "Local value")
myMethodIL.Emit(OpCodes.Stloc_0, myLocalBuilder)

' End the scope of 'myLocalBuilder'.
myMethodIL.EndScope()

' Access the local variable outside the scope.
Console.WriteLine(ControlChars.NewLine + "Trying to access the local variable outside " + _
                                          "the scope:" + ControlChars.NewLine)
myMethodIL.Emit(OpCodes.Stloc_0, myLocalBuilder)
myMethodIL.Emit(OpCodes.Ldloc_0)
myMethodIL.Emit(OpCodes.Ret)

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

[C#] 
// Get the current AppDomain.
AppDomain myAppDomain = AppDomain.CurrentDomain;
AssemblyName myAssemblyName = new AssemblyName();
myAssemblyName.Name = "SampleAssembly";

// Create a dynamic assembly 'myAssembly' with access mode 'Run'.
AssemblyBuilder myAssembly = myAppDomain.DefineDynamicAssembly(
                        myAssemblyName, AssemblyBuilderAccess.Run);
// Create a dynamic module 'myModule' in 'myAssembly'.
ModuleBuilder myModule=myAssembly.DefineDynamicModule("MyDynamicModule",true);
// Define a public class 'MyDynamicClass'.
TypeBuilder myTypeBuilder = myModule.DefineType("MyDynamicClass",
                                 TypeAttributes.Public);
// Define a public string field.
FieldBuilder myField = myTypeBuilder.DefineField("MyDynamicField", 
                         typeof(String), FieldAttributes.Public);
// Create the constructor.
Type[] myConstructorArgs = {typeof(String)};
ConstructorBuilder myConstructor = myTypeBuilder.DefineConstructor(
   MethodAttributes.Public, CallingConventions.Standard, myConstructorArgs);

// Generate IL for 'myConstructor'.
ILGenerator myConstructorIL = myConstructor.GetILGenerator();
// Emit the necessary opcodes.
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);

// Define a dynamic method named 'MyDynamicMethod'.
MethodBuilder myMethod = myTypeBuilder.DefineMethod("MyDynamicMethod",
   MethodAttributes.Public, typeof(String), null);
// Generate IL for 'myMethod'.
ILGenerator myMethodIL = myMethod.GetILGenerator();

// Begin the scope for a local variable.
myMethodIL.BeginScope();

LocalBuilder myLocalBuilder = myMethodIL.DeclareLocal(typeof(int));
Console.WriteLine("\nTrying to access the local variable within the scope.");
Console.WriteLine("'myLocalBuilder' type is :{0}", myLocalBuilder.LocalType);
myMethodIL.Emit(OpCodes.Ldstr, "Local value");
myMethodIL.Emit(OpCodes.Stloc_0, myLocalBuilder);

// End the scope of 'myLocalBuilder'.
myMethodIL.EndScope();

// Access the local variable outside the scope.
Console.WriteLine("\nTrying to access the local variable outside the scope:\n");
myMethodIL.Emit(OpCodes.Stloc_0, myLocalBuilder);
myMethodIL.Emit(OpCodes.Ldloc_0 );
myMethodIL.Emit(OpCodes.Ret );

// Create 'MyDynamicClass' class.
Type myType1 = myTypeBuilder.CreateType();

[C++] 
// Get the current AppDomain.
AppDomain* myAppDomain = AppDomain::CurrentDomain;
AssemblyName* myAssemblyName = new AssemblyName();
myAssemblyName->Name = S"SampleAssembly";

// Create a dynamic assembly 'myAssembly' with access mode 'Run'.
AssemblyBuilder* myAssembly = myAppDomain->DefineDynamicAssembly(
   myAssemblyName, AssemblyBuilderAccess::Run);
// Create a dynamic module 'myModule' in 'myAssembly'.
ModuleBuilder* myModule=myAssembly->DefineDynamicModule(S"MyDynamicModule",true);
// Define a public class 'MyDynamicClass'.
TypeBuilder* myTypeBuilder = myModule->DefineType(S"MyDynamicClass",
   TypeAttributes::Public);
// Define a public string field.
FieldBuilder* myField = myTypeBuilder->DefineField(S"MyDynamicField", 
   __typeof(String), FieldAttributes::Public);
// Create the constructor.
Type* myConstructorArgs[] = {__typeof(String)};
ConstructorBuilder* myConstructor = myTypeBuilder->DefineConstructor(
   MethodAttributes::Public, CallingConventions::Standard, myConstructorArgs);

// Generate IL for 'myConstructor'.
ILGenerator* myConstructorIL = myConstructor->GetILGenerator();
// Emit the necessary opcodes.
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);

// Define a dynamic method named 'MyDynamicMethod'.
MethodBuilder* myMethod = myTypeBuilder->DefineMethod(S"MyDynamicMethod",
   MethodAttributes::Public, __typeof(String), 0);
// Generate IL for 'myMethod'.
ILGenerator* myMethodIL = myMethod->GetILGenerator();

// Begin the scope for a local variable.
myMethodIL->BeginScope();

LocalBuilder* myLocalBuilder = myMethodIL->DeclareLocal(__typeof(int));
Console::WriteLine(S"\nTrying to access the local variable within the scope.");
Console::WriteLine(S"'myLocalBuilder' type is :{0}", myLocalBuilder->LocalType);
myMethodIL->Emit(OpCodes::Ldstr, S"Local value");
myMethodIL->Emit(OpCodes::Stloc_0, myLocalBuilder);

// End the scope of 'myLocalBuilder'.
myMethodIL->EndScope();

// Access the local variable outside the scope.
Console::WriteLine(S"\nTrying to access the local variable outside the scope:\n");
myMethodIL->Emit(OpCodes::Stloc_0, myLocalBuilder);
myMethodIL->Emit(OpCodes::Ldloc_0 );
myMethodIL->Emit(OpCodes::Ret );

// Create 'MyDynamicClass' class.
Type* myType1 = myTypeBuilder->CreateType();

必要条件

プラットフォーム: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 ファミリ

参照

ILGenerator クラス | ILGenerator メンバ | System.Reflection.Emit 名前空間