ILGenerator.BeginFaultBlock メソッド

MSIL (Microsoft Intermediate Language) ストリームで例外フォールト ブロックを開始します。

Public Overridable Sub BeginFaultBlock()
[C#]
public virtual void BeginFaultBlock();
[C++]
public: virtual void BeginFaultBlock();
[JScript]
public function BeginFaultBlock();

例外

解説

次のコード例は、 BeginFaultBlock の使用方法を示しています。

 
Imports System
Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit

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

[C#] 
using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;

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

[C++] 
#using <mscorlib.dll>
using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;

Type* AddType()
{
   // Create an assembly.
   AssemblyName* myAssemblyName = new AssemblyName();
   myAssemblyName->Name = S"AdderExceptionAsm";

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

   // Create a dynamic module.
   ModuleBuilder* myModuleBuilder =
      myAssemblyBuilder->DefineDynamicModule(S"AdderExceptionMod");
   TypeBuilder* myTypeBuilder = myModuleBuilder->DefineType(S"Adder");
   Type* myAdderParams[] = {__typeof(int), __typeof(int)};

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

   // Create constructor.

   Type* temp0 [] = {__typeof(String)};
   ConstructorInfo* myConstructorInfo = __typeof(OverflowException)->GetConstructor(temp0);
   MethodInfo* myExToStrMI = __typeof(OverflowException)->GetMethod(S"ToString");

   Type* temp1 [] = {__typeof(String),__typeof(Object)};
   MethodInfo* myWriteLineMI = __typeof(Console)->GetMethod(S"WriteLine",temp1);

   // 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, S"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(S"Fault block called.");
   //Throw exception.
   myAdderIL->ThrowException(__typeof(NotSupportedException));

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

   myAdderIL->Emit(OpCodes::Ldstr, S"{0}");
   myAdderIL->Emit(OpCodes::Ldloc_S, myLocalBuilder2);
   myAdderIL->EmitCall(OpCodes::Callvirt, myExToStrMI, 0);
   myAdderIL->EmitCall(OpCodes::Call, myWriteLineMI, 0);
   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);
   Object* myObject2[] = {__box(11),__box(12)};

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

必要条件

プラットフォーム: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 ファミリ

参照

ILGenerator クラス | ILGenerator メンバ | System.Reflection.Emit 名前空間