Imports System
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 'Main
End Class 'ILGenerator_BeginFaultBlock

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();
   }
   [PermissionSetAttribute(SecurityAction.Demand, Name="FullTrust")]
   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);
   }
}

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