ILGenerator.BeginFaultBlock Method

Reference

Definition

Namespace:: System.Reflection.Emit

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

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

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

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Source:: ILGenerator.cs

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Begins an exception fault block in the Microsoft intermediate language (MSIL) stream.

public:
 virtual void BeginFaultBlock();

public:
 abstract void BeginFaultBlock();

public virtual void BeginFaultBlock ();

public abstract void BeginFaultBlock ();

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

abstract member BeginFaultBlock : unit -> unit

Public Overridable Sub BeginFaultBlock ()

Public MustOverride Sub BeginFaultBlock ()

Exceptions

NotSupportedException

The MSIL being generated is not currently in an exception block.

-or-

This ILGenerator belongs to a DynamicMethod.

Examples

The following code sample illustrates the use of BeginFaultBlock.

using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

Type^ AddType()
{
   // Create an assembly.
   AssemblyName^ myAssemblyName = gcnew 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" );
   array<Type^>^myAdderParams = {int::typeid,int::typeid};

   // Method to add two numbers.
   MethodBuilder^ myMethodBuilder = myTypeBuilder->DefineMethod( "DoAdd", static_cast<MethodAttributes>(MethodAttributes::Public | MethodAttributes::Static), int::typeid, myAdderParams );
   ILGenerator^ myAdderIL = myMethodBuilder->GetILGenerator();

   // Create constructor.
   array<Type^>^temp0 = {String::typeid};
   ConstructorInfo^ myConstructorInfo = OverflowException::typeid->GetConstructor( temp0 );
   MethodInfo^ myExToStrMI = OverflowException::typeid->GetMethod( "ToString" );
   array<Type^>^temp1 = {String::typeid,Object::typeid};
   MethodInfo^ myWriteLineMI = Console::typeid->GetMethod( "WriteLine", temp1 );

   // Declare local variable.
   LocalBuilder^ myLocalBuilder1 = myAdderIL->DeclareLocal( int::typeid );
   LocalBuilder^ myLocalBuilder2 = myAdderIL->DeclareLocal( OverflowException::typeid );

   // 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 addition." );
   myAdderIL->Emit( OpCodes::Newobj, myConstructorInfo );
   myAdderIL->Emit( OpCodes::Stloc_S, myLocalBuilder2 );
   myAdderIL->Emit( OpCodes::Ldloc_S, myLocalBuilder2 );

   // Call fault block.
   myAdderIL->BeginFaultBlock();
   Console::WriteLine( "Fault block called." );

   //Throw exception.
   myAdderIL->ThrowException( NotSupportedException::typeid );

   // Call finally block.
   myAdderIL->BeginFinallyBlock();
   myAdderIL->Emit( OpCodes::Ldstr, "{0}" );
   myAdderIL->Emit( OpCodes::Ldloc_S, myLocalBuilder2 );
   myAdderIL->EmitCall( OpCodes::Callvirt, myExToStrMI, nullptr );
   myAdderIL->EmitCall( OpCodes::Call, myWriteLineMI, nullptr );
   myAdderIL->Emit( OpCodes::Ldc_I4_M1 );
   myAdderIL->Emit( OpCodes::Stloc_S, myLocalBuilder1 );

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

int main()
{
   Type^ myAddType = AddType();
   Object^ myObject1 = Activator::CreateInstance( myAddType );
   array<Object^>^myObject2 = {11,12};

   // Invoke member.
   myAddType->InvokeMember( "DoAdd", BindingFlags::InvokeMethod, nullptr, myObject1, myObject2 );
}

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

public class ILGenerator_BeginFaultBlock
{
   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[] myAdderParams = new Type[] {typeof(int), typeof(int)};

      // Method to add two numbers.
      MethodBuilder myMethodBuilder = myTypeBuilder.DefineMethod("DoAdd",MethodAttributes.Public |
         MethodAttributes.Static,typeof(int),myAdderParams);
      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 addition.");
      myAdderIL.Emit(OpCodes.Newobj, myConstructorInfo);

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

      // Call fault block.
      myAdderIL.BeginFaultBlock();
      Console.WriteLine("Fault block called.");
      //Throw exception.
      myAdderIL.ThrowException(typeof(NotSupportedException));

      // Call finally block.
      myAdderIL.BeginFinallyBlock();

      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);

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

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

      return myTypeBuilder.CreateType();
   }
   
   public static void Main()
   {
      Type myAddType = AddType();
      object myObject1 = Activator.CreateInstance(myAddType);
      object[] myObject2 = new object[]{11,12};

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

Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit
Imports System.Security.Permissions

Public Class ILGenerator_BeginFaultBlock
   Public Shared Function AddType() As Type
      ' Create an assembly.
      Dim myAssemblyName As New AssemblyName()
      myAssemblyName.Name = "AdderExceptionAsm"
      
      ' Create dynamic assembly.
      Dim myAppDomain As AppDomain = Thread.GetDomain()
      Dim myAssemblyBuilder As AssemblyBuilder = myAppDomain.DefineDynamicAssembly _ 
                                              (myAssemblyName, AssemblyBuilderAccess.Run)
      
      ' Create a dynamic module.
      Dim myModuleBuilder As ModuleBuilder = myAssemblyBuilder.DefineDynamicModule _ 
                                                ("AdderExceptionMod")
      Dim myTypeBuilder As TypeBuilder = myModuleBuilder.DefineType("Adder")
      Dim myAdderParams() As Type = {GetType(Integer), GetType(Integer)}
      
      ' Method to add two numbers.
      Dim myMethodBuilder As MethodBuilder = myTypeBuilder.DefineMethod _ 
               ("DoAdd", MethodAttributes.Public Or MethodAttributes.Static, GetType(Integer), _
                                                  myAdderParams)
      Dim myAdderIL As ILGenerator = myMethodBuilder.GetILGenerator()
      
      ' Create constructor.
      Dim myConstructorInfo As ConstructorInfo = GetType(OverflowException).GetConstructor _ 
                                                   (New Type() {GetType(String)})
      Dim myExToStrMI As MethodInfo = GetType(OverflowException).GetMethod("ToString")
      Dim myWriteLineMI As MethodInfo = GetType(Console).GetMethod _ 
                                  ("WriteLine", New Type() {GetType(String), GetType(Object)})
      
      ' Declare local variable.
      Dim myLocalBuilder1 As LocalBuilder = myAdderIL.DeclareLocal(GetType(Integer))
      Dim myLocalBuilder2 As LocalBuilder = myAdderIL.DeclareLocal(GetType(OverflowException))
      
      ' Define label.
      Dim myFailedLabel As Label = myAdderIL.DefineLabel()
      Dim myEndOfMethodLabel As Label = myAdderIL.DefineLabel()
      
      ' Begin exception block.
      Dim myLabel As Label = 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 addition.")
      myAdderIL.Emit(OpCodes.Newobj, myConstructorInfo)
      
      myAdderIL.Emit(OpCodes.Stloc_S, myLocalBuilder2)
      myAdderIL.Emit(OpCodes.Ldloc_S, myLocalBuilder2)
      
      ' Call fault block.
      myAdderIL.BeginFaultBlock()
      Console.WriteLine("Fault block called.")
      'Throw exception.
      myAdderIL.ThrowException(GetType(NotSupportedException))
      
      ' Call finally block.
      myAdderIL.BeginFinallyBlock()
      
      myAdderIL.Emit(OpCodes.Ldstr, "{0}")
      myAdderIL.Emit(OpCodes.Ldloc_S, myLocalBuilder2)
      myAdderIL.EmitCall(OpCodes.Callvirt, myExToStrMI, Nothing)
      myAdderIL.EmitCall(OpCodes.Call, myWriteLineMI, Nothing)
      myAdderIL.Emit(OpCodes.Ldc_I4_M1)
      myAdderIL.Emit(OpCodes.Stloc_S, myLocalBuilder1)
      
      ' End exception block.
      myAdderIL.EndExceptionBlock()
      
      myAdderIL.MarkLabel(myEndOfMethodLabel)
      myAdderIL.Emit(OpCodes.Ldloc_S, myLocalBuilder1)
      myAdderIL.Emit(OpCodes.Ret)
      
      Return myTypeBuilder.CreateType()
   End Function 'AddType
   
   <PermissionSetAttribute(SecurityAction.Demand, Name:="FullTrust")> _   
   Public Shared Sub Main()
      Dim myAddType As Type = AddType()
      Dim myObject1 As Object = Activator.CreateInstance(myAddType)
      Dim myObject2() As Object = {11, 12}
      
      ' Invoke member.
      myAddType.InvokeMember("DoAdd", BindingFlags.InvokeMethod, Nothing, myObject1, myObject2)
   End Sub
End Class

Remarks

If the current ILGenerator is associated with a DynamicMethod object, emitting exception fault blocks is not supported. DynamicILInfo can be used to construct a dynamic method that uses exception fault blocks.

Applies to

Jagamisviis: