Esta documentación está archivada y no tiene mantenimiento.

ILGenerator.BeginFinallyBlock (Método)

Inicia un bloque finally en la secuencia de instrucciones máquina del Lenguaje intermedio de Microsoft (MSIL).

Espacio de nombres: System.Reflection.Emit
Ensamblado: mscorlib (en mscorlib.dll)

public virtual void BeginFinallyBlock ()
public void BeginFinallyBlock ()
public function BeginFinallyBlock ()

Tipo de excepciónCondición

NotSupportedException

El Lenguaje intermedio de Microsoft (MSIL) que se está generando no está incluido actualmente en un bloque de excepción.

En el siguiente ejemplo de código se muestra el uso de BeginFinallyBlock.

using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
using System.Security.Permissions;

public class ILGenerator_BeginFinallyBlock
{
   public static Type AddType()
   {
      // Create an assembly.
      AssemblyName myAssemblyName = new AssemblyName();
      myAssemblyName.Name = "AdderExceptionAsm";

      // Create dynamic assembly.
      AppDomain myAppDomain = Thread.GetDomain();
      AssemblyBuilder myAssemblyBuilder = myAppDomain.DefineDynamicAssembly(myAssemblyName,
         AssemblyBuilderAccess.Run);

      // Create a dynamic module.
      ModuleBuilder myModuleBuilder = myAssemblyBuilder.DefineDynamicModule("AdderExceptionMod");
      TypeBuilder myTypeBuilder = myModuleBuilder.DefineType("Adder");
      Type[] adderParams = new Type[] {typeof(int), typeof(int)};

      // Define method to add two numbers.
      MethodBuilder myMethodBuilder = myTypeBuilder.DefineMethod("DoAdd",MethodAttributes.Public |
         MethodAttributes.Static,typeof(int),adderParams);
      ILGenerator myAdderIL = myMethodBuilder.GetILGenerator();

      // Create constructor.
      ConstructorInfo myConstructorInfo = typeof(OverflowException).GetConstructor(
         new Type[]{typeof(string)});
      MethodInfo myExToStrMI = typeof(OverflowException).GetMethod("ToString");
      MethodInfo myWriteLineMI = typeof(Console).GetMethod("WriteLine",new Type[]
         {typeof(string),typeof(object)});

      // Declare local variable.
      LocalBuilder myLocalBuilder1 = myAdderIL.DeclareLocal(typeof(int));
      LocalBuilder myLocalBuilder2 = myAdderIL.DeclareLocal(typeof(OverflowException));

      // Define label.
      Label myFailedLabel = myAdderIL.DefineLabel();
      Label myEndOfMethodLabel = myAdderIL.DefineLabel();

      // Begin exception block.
      Label myLabel = myAdderIL.BeginExceptionBlock();

      myAdderIL.Emit(OpCodes.Ldarg_0);
      myAdderIL.Emit(OpCodes.Ldc_I4_S, 10);
      myAdderIL.Emit(OpCodes.Bgt_S, myFailedLabel);

      myAdderIL.Emit(OpCodes.Ldarg_1);
      myAdderIL.Emit(OpCodes.Ldc_I4_S, 10);
      myAdderIL.Emit(OpCodes.Bgt_S, myFailedLabel);

      myAdderIL.Emit(OpCodes.Ldarg_0);
      myAdderIL.Emit(OpCodes.Ldarg_1);
      myAdderIL.Emit(OpCodes.Add_Ovf_Un);
      myAdderIL.Emit(OpCodes.Stloc_S, myLocalBuilder1);
      myAdderIL.Emit(OpCodes.Br_S, myEndOfMethodLabel);

      myAdderIL.MarkLabel(myFailedLabel);
      myAdderIL.Emit(OpCodes.Ldstr, "Cannot accept values over 10 for add.");
      myAdderIL.Emit(OpCodes.Newobj, myConstructorInfo);

      myAdderIL.Emit(OpCodes.Stloc_S, myLocalBuilder2);
      myAdderIL.Emit(OpCodes.Ldloc_S, myLocalBuilder2);

      // Throw the exception.
      myAdderIL.ThrowException(typeof(OverflowException));

      // Call 'BeginExceptFilterBlock'.
      myAdderIL.BeginExceptFilterBlock();
      myAdderIL.EmitWriteLine("Except filter block called.");

      // Call catch block.
      myAdderIL.BeginCatchBlock(null);
      
      // Call other catch block.
      myAdderIL.BeginCatchBlock(typeof(OverflowException));

      myAdderIL.Emit(OpCodes.Ldstr, "{0}");
      myAdderIL.Emit(OpCodes.Ldloc_S, myLocalBuilder2);
      myAdderIL.EmitCall(OpCodes.Callvirt, myExToStrMI, null);
      myAdderIL.EmitCall(OpCodes.Call, myWriteLineMI, null);
      myAdderIL.Emit(OpCodes.Ldc_I4_M1);
      myAdderIL.Emit(OpCodes.Stloc_S, myLocalBuilder1);

      // Call finally block.
      myAdderIL.BeginFinallyBlock();
      myAdderIL.EmitWriteLine("Finally block called.");

      // End the exception block.
      myAdderIL.EndExceptionBlock();

      myAdderIL.MarkLabel(myEndOfMethodLabel);
      myAdderIL.Emit(OpCodes.Ldloc_S, myLocalBuilder1);
      myAdderIL.Emit(OpCodes.Ret);

      return myTypeBuilder.CreateType();
   }
   [PermissionSetAttribute(SecurityAction.Demand, Name="FullTrust")]
   public static void Main()
   {
      Type myAddType = AddType();
      object myObject1 = Activator.CreateInstance(myAddType);
      object[] myObject2 = new object[]{15,15};
      myAddType.InvokeMember("DoAdd", BindingFlags.InvokeMethod,
         null, myObject1, myObject2);
   }
}

import System.*;
import System.Threading.*;
import System.Reflection.*;
import System.Reflection.Emit.*;

public class ILGenerator_BeginFinallyBlock
{
    public static Type AddType()
    {
        // Create an assembly.
        AssemblyName myAssemblyName = new AssemblyName();
        myAssemblyName.set_Name("AdderExceptionAsm");

        // Create dynamic assembly.
        AppDomain myAppDomain = System.Threading.Thread.GetDomain();
        AssemblyBuilder myAssemblyBuilder = myAppDomain.DefineDynamicAssembly(
            myAssemblyName, AssemblyBuilderAccess.Run);

        // Create a dynamic module.
        ModuleBuilder myModuleBuilder = myAssemblyBuilder.
            DefineDynamicModule("AdderExceptionMod");
        TypeBuilder myTypeBuilder = myModuleBuilder.DefineType("Adder");
        Type adderParams[] = new Type[] {int.class.ToType(), 
            int.class.ToType() };

        // Define method to add two numbers.
        MethodBuilder myMethodBuilder = myTypeBuilder.
            DefineMethod("DoAdd", MethodAttributes.Public | 
            MethodAttributes.Static, int.class.ToType(), adderParams);
        ILGenerator myAdderIL = myMethodBuilder.GetILGenerator();

        // Create constructor.
        ConstructorInfo myConstructorInfo = OverflowException.class.
            ToType().GetConstructor(new Type[] { String.class.ToType() });
        MethodInfo myExToStrMI = OverflowException.class.ToType().
            GetMethod("ToString");
        MethodInfo myWriteLineMI = Console.class.ToType().
            GetMethod("WriteLine", new Type[] { String.class.
                ToType(), Object.class.ToType() });

        // Declare local variable.
        LocalBuilder myLocalBuilder1 = myAdderIL.DeclareLocal(int.
            class.ToType());
        LocalBuilder myLocalBuilder2 = myAdderIL.DeclareLocal(
            OverflowException.class.ToType());
        // Define label.
        Label myFailedLabel = myAdderIL.DefineLabel();
        Label myEndOfMethodLabel = myAdderIL.DefineLabel();
        // Begin exception block.
        Label myLabel = myAdderIL.BeginExceptionBlock();

        myAdderIL.Emit(OpCodes.Ldarg_0);
        myAdderIL.Emit(OpCodes.Ldc_I4_S, 10);
        myAdderIL.Emit(OpCodes.Bgt_S, myFailedLabel);
        myAdderIL.Emit(OpCodes.Ldarg_1);
        myAdderIL.Emit(OpCodes.Ldc_I4_S, 10);
        myAdderIL.Emit(OpCodes.Bgt_S, myFailedLabel);
        myAdderIL.Emit(OpCodes.Ldarg_0);
        myAdderIL.Emit(OpCodes.Ldarg_1);
        myAdderIL.Emit(OpCodes.Add_Ovf_Un);
        myAdderIL.Emit(OpCodes.Stloc_S, myLocalBuilder1);
        myAdderIL.Emit(OpCodes.Br_S, myEndOfMethodLabel);
        myAdderIL.MarkLabel(myFailedLabel);
        myAdderIL.Emit(OpCodes.Ldstr, "Cannot accept values over 10 for add.");
        myAdderIL.Emit(OpCodes.Newobj, myConstructorInfo);
        myAdderIL.Emit(OpCodes.Stloc_S, myLocalBuilder2);
        myAdderIL.Emit(OpCodes.Ldloc_S, myLocalBuilder2);

        // Throw the exception.
        myAdderIL.ThrowException(OverflowException.class.ToType());

        // Call 'BeginExceptFilterBlock'.
        myAdderIL.BeginExceptFilterBlock();
        myAdderIL.EmitWriteLine("Except filter block called.");

        // Call catch block.
        myAdderIL.BeginCatchBlock(null);

        // Call other catch block.
        myAdderIL.BeginCatchBlock(OverflowException.class.ToType());
        myAdderIL.Emit(OpCodes.Ldstr, "{0}");
        myAdderIL.Emit(OpCodes.Ldloc_S, myLocalBuilder2);
        myAdderIL.EmitCall(OpCodes.Callvirt, myExToStrMI, null);
        myAdderIL.EmitCall(OpCodes.Call, myWriteLineMI, null);
        myAdderIL.Emit(OpCodes.Ldc_I4_M1);
        myAdderIL.Emit(OpCodes.Stloc_S, myLocalBuilder1);

        // Call finally block.
        myAdderIL.BeginFinallyBlock();
        myAdderIL.EmitWriteLine("Finally block called.");

        // End the exception block.
        myAdderIL.EndExceptionBlock();
        myAdderIL.MarkLabel(myEndOfMethodLabel);
        myAdderIL.Emit(OpCodes.Ldloc_S, myLocalBuilder1);
        myAdderIL.Emit(OpCodes.Ret);
        return myTypeBuilder.CreateType();
    } //AddType

    public static void main(String[] args)
    {
        Type myAddType = AddType();
        Object myObject1 = Activator.CreateInstance(myAddType);
        Object myObject2[] = new Object[] { (Int32) 15,
            (Int32)15 };

        myAddType.InvokeMember("DoAdd", BindingFlags.InvokeMethod,
            null, myObject1, myObject2);
    } //main
} //ILGenerator_BeginFinallyBlock

Windows 98, Windows 2000 SP4, Windows Millennium, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter Edition

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

.NET Framework

Compatible con: 2.0, 1.1, 1.0
Mostrar: