ILGenerator.BeginFaultBlock Method

Imports System.Reflection
Imports System.Reflection.Emit

Public Class Example

   Public Shared Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock) 

      ' Put the TextBlock in a location where the PrintHelper method can 
      ' use it.
      Example.outputBlock = outputBlock

      ' Create the dynamic assembly. In Silverlight, dynamic assemblies are
      ' transient and have only one module.
      Dim aName As New AssemblyName("EmitDemo")
      Dim ab As AssemblyBuilder = _
         AppDomain.CurrentDomain.DefineDynamicAssembly(aName, _
                                                       AssemblyBuilderAccess.Run)
      Dim mb As ModuleBuilder = ab.DefineDynamicModule("EmitDemo")

      ' Define a public type.
      Dim tt As TypeBuilder = mb.DefineType("TestType", TypeAttributes.Public)

      ' Define the Shared TestMethod method, which has one string parameter and 
      ' no return value. TestMethod passes its argument to Example.ThrowHelper,
      ' which throws different exceptions depending on the value of the argument.
      ' TestMethod handles one exception, and does not handle the other.
      Dim tm As MethodBuilder = _
         tt.DefineMethod("TestMethod", _
                         MethodAttributes.Public Or MethodAttributes.Static, _
                         Nothing, _
                         New Type() { GetType(String) })

      ' Get MethodInfo objects that represent the Example.PrintHelper method, 
      ' for writing to the TextBlock, and Example.ThrowHelper, for throwing
      ' exceptions conditionally.
      Dim printhelper As MethodInfo = GetType(Example).GetMethod("PrintHelper")
      Dim throwhelper As MethodInfo = GetType(Example).GetMethod("ThrowHelper")

      Dim il As ILGenerator = tm.GetILGenerator()

      ' Begin the outermost exception block, which includes the fault handler.
      ' The ECMA spec specifies that a protected block of code shall have only
      ' one kind of handler.
      Dim tryFault As Label = il.BeginExceptionBlock()

      ' Begin the middle exception block, which includes the finally handler.
      ' There is no rule about the order of nesting of the fault and finally
      ' handlers.
      Dim tryFinally As Label = il.BeginExceptionBlock()

      ' Begin the innermost exception block, which includes the catch handlers.
      Dim tryCatch As Label = il.BeginExceptionBlock()

      ' Load the argument string and pass it to the Shared Example.TestThrows
      ' method. The called method throws different exceptions if the argument
      ' is null or of zero length; it throws no exception otherwise.
      il.Emit(OpCodes.Ldarg_0)
      il.Emit(OpCodes.Call, throwhelper)

      ' If the call to Example.TestThrows ended normally, display a message and
      ' exit from the innermost exception block.
      il.Emit(OpCodes.Ldstr, "TestMethod: ThrowHelper ended normally.")
      il.Emit(OpCodes.Call, printhelper)
      il.Emit(OpCodes.Leave, tryCatch)

      ' Catch ArgumentNullException, display a message, and exit from the inner
      ' try/catch.
      il.BeginCatchBlock(GetType(ArgumentNullException))
      il.Emit(OpCodes.Ldstr, "TestMethod: Caught ArgumentNullException.")
      il.Emit(OpCodes.Call, printhelper)
      il.Emit(OpCodes.Leave, tryCatch)

      ' The end of the innermost exception block. 
      il.EndExceptionBlock()


      ' If the protected code ended normally, or if an exception was caught 
      ' and handled, exit from the middle exception block.
      il.Emit(OpCodes.Leave, tryFinally)

      ' The finally block displays a message.
      il.BeginFinallyBlock()
      il.Emit(OpCodes.Ldstr, "TestMethod: Finally block runs.")
      il.Emit(OpCodes.Call, printhelper)

      ' The end of the middle exception block. 
      il.EndExceptionBlock()


      ' If the protected code ended normally, or if an exception was caught 
      ' and handled, exit from the outermost exception block.
      il.Emit(OpCodes.Leave, tryFault)


      ' Begin the fault block, in the outermost exception block. The fault block
      ' displays a message. As with finally blocks, you do not use a Leave to
      ' exit from the fault block.
      il.BeginFaultBlock()
      il.Emit(OpCodes.Ldstr, "TestMethod: Fault block runs.")
      il.Emit(OpCodes.Call, printhelper)


      ' The end of the outermost exception block.
      il.EndExceptionBlock()

      il.Emit(OpCodes.Ret)


      Dim t As Type = tt.CreateType()

      ' Get a MethodInfo for TestMethod, and create a delegate to execute the
      ' method.
      Dim tmx As MethodInfo = t.GetMethod("TestMethod")
      Dim callTestMethod As StringSub = _
         CType([Delegate].CreateDelegate(GetType(StringSub), tmx), StringSub)

      ' Note that it is not necessary to declare your own delegate type. 
      ' Alternatively, you could use a generic delegate type as shown here:
      'Dim callTestMethod As Action(Of String) = _
      '   CType([Delegate].CreateDelegate(GetType(Action(Of String)), tmx), _
      '         Action(Of String))

      Example.PrintHelper("Normal execution, no exceptions thrown:")
      callTestMethod("test")


      Example.PrintHelper(vbLf & _
         "An exception is thrown and caught in the innermost block:")
      callTestMethod(Nothing)


      Example.PrintHelper(vbLf & _
         "An exception is thrown and not caught in the innermost block:")
      Try
         callTestMethod("")
      Catch ex As ArgumentException
         Example.PrintHelper("Demo: Caught ArgumentException """ & _
                             ex.Message & """")
      End Try
   End Sub 

   Delegate Sub StringSub(ByVal s As String)

   ' HELPER METHODS: The emitted code calls the ThrowHelper and PrintHelper 
   ' methods to throw exceptions conditionally and to display output. This 
   ' is done in order to simplify the emitted code.

   ' Throw ArgumentNullException if the argument is Nothing; if the argument
   ' has zero length, throw ArgumentException.
   Public Shared Sub ThrowHelper(ByVal text As String)
      If text Is Nothing Then
         Throw New ArgumentNullException("Parameter 'text' must not be null.")
      Else If text.Length = 0 Then
         Throw New ArgumentException("Parameter 'text' must have length > 0.")
      End If
   End Sub

   Private Shared outputBlock As System.Windows.Controls.TextBlock

   Public Shared Sub PrintHelper(ByVal msg As String)
      outputBlock.Text &= msg & vbLf
   End Sub

End Class 

' This example produces output similar to the following:
'
'Normal execution, no exceptions thrown:
'TestMethod: ThrowHelper ended normally.
'TestMethod: Finally block runs.
'
'An exception is thrown and caught in the innermost block:
'TestMethod: Caught ArgumentNullException.
'TestMethod: Finally block runs.
'
'An exception is thrown and not caught in the innermost block:
'TestMethod: Finally block runs.
'TestMethod: Fault block runs.
'Demo: Caught ArgumentException "Parameter 'text' must have length > 0."

using System;
using System.Reflection;
using System.Reflection.Emit;

public class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      // Put the TextBlock in a location where the PrintHelper method can 
      // use it.
      Example.outputBlock = outputBlock;

      // Create the dynamic assembly. In Silverlight, dynamic assemblies are
      // transient and have only one module.
      AssemblyName aName = new AssemblyName("EmitDemo");
      AssemblyBuilder ab = 
         AppDomain.CurrentDomain.DefineDynamicAssembly(aName, 
                                                       AssemblyBuilderAccess.Run);
      ModuleBuilder mb = ab.DefineDynamicModule("EmitDemo");

      // Define a public type.
      TypeBuilder tt = mb.DefineType("TestType", TypeAttributes.Public);

      // Define the static TestMethod method, which has one string parameter and 
      // no return value. TestMethod passes its argument to Example.ThrowHelper,
      // which throws different exceptions depending on the value of the argument.
      // TestMethod handles one exception, and does not handle the other.
      MethodBuilder tm = 
         tt.DefineMethod("TestMethod", 
                         MethodAttributes.Public | MethodAttributes.Static, 
                         null, 
                         new Type[] { typeof(string) });

      // Get MethodInfo objects that represent the Example.PrintHelper method, 
      // for writing to the TextBlock, and Example.ThrowHelper, for throwing
      // exceptions conditionally.
      MethodInfo printhelper = typeof(Example).GetMethod("PrintHelper");
      MethodInfo throwhelper = typeof(Example).GetMethod("ThrowHelper");

      ILGenerator il = tm.GetILGenerator();

      // Begin the outermost exception block, which includes the fault handler.
      // The ECMA spec specifies that a protected block of code shall have only
      // one kind of handler.
      Label tryFault = il.BeginExceptionBlock();

      // Begin the middle exception block, which includes the finally handler.
      // There is no rule about the order of nesting of the fault and finally
      // handlers.
      Label tryFinally = il.BeginExceptionBlock();

      // Begin the innermost exception block, which includes the catch handlers.
      Label tryCatch = il.BeginExceptionBlock();

      // Load the argument string and pass it to the static Example.TestThrows
      // method. The called method throws different exceptions if the argument
      // is null or of zero length; it throws no exception otherwise.
      il.Emit(OpCodes.Ldarg_0);
      il.Emit(OpCodes.Call, throwhelper);

      // If the call to Example.TestThrows ended normally, display a message and
      // exit from the innermost exception block.
      il.Emit(OpCodes.Ldstr, "TestMethod: ThrowHelper ended normally.");
      il.Emit(OpCodes.Call, printhelper);
      il.Emit(OpCodes.Leave, tryCatch);

      // Catch ArgumentNullException, display a message, and exit from the inner
      // try/catch.
      il.BeginCatchBlock(typeof(ArgumentNullException));
      il.Emit(OpCodes.Ldstr, "TestMethod: Caught ArgumentNullException.");
      il.Emit(OpCodes.Call, printhelper);
      il.Emit(OpCodes.Leave, tryCatch);

      // The end of the innermost exception block. 
      il.EndExceptionBlock();


      // If the protected code ended normally, or if an exception was caught 
      // and handled, exit from the middle exception block.
      il.Emit(OpCodes.Leave, tryFinally);

      // The finally block displays a message.
      il.BeginFinallyBlock();
      il.Emit(OpCodes.Ldstr, "TestMethod: Finally block runs.");
      il.Emit(OpCodes.Call, printhelper);

      // The end of the middle exception block. 
      il.EndExceptionBlock();


      // If the protected code ended normally, or if an exception was caught 
      // and handled, exit from the outermost exception block.
      il.Emit(OpCodes.Leave, tryFault);


      // Begin the fault block, in the outermost exception block. The fault block
      // displays a message. As with finally blocks, you do not use a Leave to
      // exit from the fault block.
      il.BeginFaultBlock();
      il.Emit(OpCodes.Ldstr, "TestMethod: Fault block runs.");
      il.Emit(OpCodes.Call, printhelper);


      // The end of the outermost exception block.
      il.EndExceptionBlock();

      il.Emit(OpCodes.Ret);


      Type t = tt.CreateType();

      // Get a MethodInfo for TestMethod, and create a delegate to execute the
      // method.
      MethodInfo tmx = t.GetMethod("TestMethod");
      StringSub callTestMethod = 
         (StringSub) Delegate.CreateDelegate(typeof(StringSub), tmx);

      // Note that it is not necessary to declare your own delegate type. 
      // Alternatively, you could use a generic delegate type as shown here:
      //Action<String> callTestMethod = 
      //   (Action<String>) Delegate.CreateDelegate(typeof(Action<String>), tmx);

      Example.PrintHelper("Normal execution, no exceptions thrown:"  );
      callTestMethod("test");


      Example.PrintHelper(
         "\nAn exception is thrown and caught in the innermost block:");
      callTestMethod(null);


      Example.PrintHelper(
         "\nAn exception is thrown and not caught in the innermost block:");
      try
      {
         callTestMethod("");
      }
      catch(ArgumentException ex)
      {
         Example.PrintHelper(
            "Demo: Caught ArgumentException \"" + ex.Message + "\"");
      }
   }

   public delegate void StringSub(string s);

   // HELPER METHODS: The emitted code calls the ThrowHelper and PrintHelper 
   // methods to throw exceptions conditionally and to display output. This 
   // is done in order to simplify the emitted code.

   // Throw ArgumentNullException if the argument is Nothing; if the argument
   // has zero length, throw ArgumentException.
   public static void ThrowHelper(string text)
   {
      if (text == null)
      {
         throw new ArgumentNullException("Parameter 'text' must not be null.");
      }
      else if (text.Length == 0)
      {
         throw new ArgumentException("Parameter 'text' must have length > 0.");
      }
   }

   private static System.Windows.Controls.TextBlock outputBlock;

   public static void PrintHelper(string msg)
   {
      outputBlock.Text += msg + "\n";
   }
}

/* This example produces output similar to the following:

Normal execution, no exceptions thrown:
TestMethod: ThrowHelper ended normally.
TestMethod: Finally block runs.

An exception is thrown and caught in the innermost block:
TestMethod: Caught ArgumentNullException.
TestMethod: Finally block runs.

An exception is thrown and not caught in the innermost block:
TestMethod: Finally block runs.
TestMethod: Fault block runs.
Demo: Caught ArgumentException "Parameter 'text' must have length > 0."
 */