ILGenerator.BeginScope Method

Definition

Namespace:

System.Reflection.Emit

Assembly:

System.Reflection.Emit.ILGeneration.dll

Source:

ILGenerator.cs

Begins a lexical scope.

public:
 abstract void BeginScope();

public abstract void BeginScope ();

abstract member BeginScope : unit -> unit

Public MustOverride Sub BeginScope ()

Exceptions

NotSupportedException

This ILGenerator belongs to a DynamicMethod.

Examples

The following code sample illustrates the use of BeginScope and EndScope.

// Get the current AppDomain.
AppDomain^ myAppDomain = AppDomain::CurrentDomain;
AssemblyName^ myAssemblyName = gcnew 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", String::typeid, FieldAttributes::Public );

// Create the constructor.
array<Type^>^myConstructorArgs = {String::typeid};
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 = 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 );

// Define a dynamic method named 'MyDynamicMethod'.
MethodBuilder^ myMethod = myTypeBuilder->DefineMethod( "MyDynamicMethod", MethodAttributes::Public, String::typeid, nullptr );

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

// Begin the scope for a local variable.
myMethodIL->BeginScope();
LocalBuilder^ myLocalBuilder = myMethodIL->DeclareLocal( int::typeid );
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();

// 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:");
myMethodIL.Emit(OpCodes.Stloc_0, myLocalBuilder);
myMethodIL.Emit(OpCodes.Ldloc_0 );
myMethodIL.Emit(OpCodes.Ret );

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

' 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:")
myMethodIL.Emit(OpCodes.Stloc_0, myLocalBuilder)
myMethodIL.Emit(OpCodes.Ldloc_0)
myMethodIL.Emit(OpCodes.Ret)

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

Remarks

This method is used to emit symbolic information. Local variables declared after BeginScope are scoped until the corresponding EndScope is called.

If the current ILGenerator is associated with a DynamicMethod object, it does not support symbolic information.