ILGenerator.BeginScope Méthode

Référence

Définition

Espace de noms:: System.Reflection.Emit

Assembly:: System.Reflection.Emit.ILGeneration.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Paquet:: System.Reflection.Emit.ILGeneration v4.7.0

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Commence une portée lexicale.

public:
 virtual void BeginScope();

public:
 abstract void BeginScope();

public virtual void BeginScope ();

public abstract void BeginScope ();

abstract member BeginScope : unit -> unit
override this.BeginScope : unit -> unit

abstract member BeginScope : unit -> unit

Public Overridable Sub BeginScope ()

Public MustOverride Sub BeginScope ()

Exceptions

NotSupportedException

Ce ILGenerator appartient à un DynamicMethod.

Exemples

L’exemple de code suivant illustre l’utilisation de BeginScope et 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()

Remarques

Cette méthode est utilisée pour émettre des informations symboliques. Les variables locales déclarées après BeginScope sont délimitées jusqu’à ce que le correspondant EndScope soit appelé.

Si le actuel ILGenerator est associé à un DynamicMethod objet, il ne prend pas en charge les informations symboliques.

S’applique à

Partager via