ILGenerator.EndExceptionBlock 메서드
예외 블록을 끝냅니다.
네임스페이스: System.Reflection.Emit
어셈블리: mscorlib(mscorlib.dll)
구문
‘선언
Public Overridable Sub EndExceptionBlock
‘사용 방법
Dim instance As ILGenerator
instance.EndExceptionBlock
public virtual void EndExceptionBlock ()
public:
virtual void EndExceptionBlock ()
public void EndExceptionBlock ()
public function EndExceptionBlock ()
예외
| 예외 형식 | 조건 |
|---|---|
코드 스트림의 예기치 않은 위치에서 end 예외 블록이 발생하는 경우 |
|
생성되는 MSIL(Microsoft Intermediate Language)이 현재 예외 블록에 들어 있지 않은 경우 |
예제
다음 코드 예제에서는 EndExceptionBlock 메서드의 상황에 따른 사용 방법을 보여 줍니다.
Imports System
Imports System.Threading
Imports System.Reflection
Imports System.Reflection.Emit
_
Class ILThrowExceptionDemo
Public Shared Function BuildAdderType() As Type
Dim myDomain As AppDomain = Thread.GetDomain()
Dim myAsmName As New AssemblyName()
myAsmName.Name = "AdderExceptionAsm"
Dim myAsmBldr As AssemblyBuilder = myDomain.DefineDynamicAssembly(myAsmName, _
AssemblyBuilderAccess.Run)
Dim myModBldr As ModuleBuilder = myAsmBldr.DefineDynamicModule("AdderExceptionMod")
Dim myTypeBldr As TypeBuilder = myModBldr.DefineType("Adder")
Dim adderParams() As Type = {GetType(Integer), GetType(Integer)}
' This method will add two numbers which are 100 or less. If either of the
' passed integer vales are greater than 100, it will throw an exception.
Dim adderBldr As MethodBuilder = myTypeBldr.DefineMethod("DoAdd", _
MethodAttributes.Public Or MethodAttributes.Static, _
GetType(Integer), adderParams)
Dim adderIL As ILGenerator = adderBldr.GetILGenerator()
' In order to successfully branch, we need to create labels
' representing the offset IL instruction block to branch to.
' These labels, when the MarkLabel(Label) method is invoked,
' will specify the IL instruction to branch to.
Dim exCtorInfo As ConstructorInfo = GetType(OverflowException).GetConstructor( _
New Type() {GetType(String)})
Dim exToStrMI As MethodInfo = GetType(OverflowException).GetMethod("ToString")
Dim writeLineMI As MethodInfo = GetType(Console).GetMethod("WriteLine", _
New Type() {GetType(String), _
GetType(Object)})
Dim tmp1 As LocalBuilder = adderIL.DeclareLocal(GetType(Integer))
Dim tmp2 As LocalBuilder = adderIL.DeclareLocal(GetType(OverflowException))
Dim failed As Label = adderIL.DefineLabel()
Dim endOfMthd As Label = adderIL.DefineLabel()
' First, load argument 0 and the integer value of "100" onto the
' stack. If arg0 > 100, branch to the label "failed", which is marked
' as the address of the block that throws an exception.
Dim exBlock As Label = adderIL.BeginExceptionBlock()
adderIL.Emit(OpCodes.Ldarg_0)
adderIL.Emit(OpCodes.Ldc_I4_S, 100)
adderIL.Emit(OpCodes.Bgt_S, failed)
' Now, check to see if argument 1 was greater than 100. If it was,
' branch to "failed." Otherwise, fall through and perform the addition,
' branching unconditionally to the instruction at the label "endOfMthd".
adderIL.Emit(OpCodes.Ldarg_1)
adderIL.Emit(OpCodes.Ldc_I4_S, 100)
adderIL.Emit(OpCodes.Bgt_S, failed)
adderIL.Emit(OpCodes.Ldarg_0)
adderIL.Emit(OpCodes.Ldarg_1)
adderIL.Emit(OpCodes.Add_Ovf_Un)
adderIL.Emit(OpCodes.Stloc_S, tmp1)
adderIL.Emit(OpCodes.Br_S, endOfMthd)
' If one of the arguments was greater than 100, we need to throw an
' exception. We'll use "OverflowException" with a customized message.
' First, we load our message onto the stack, and then create a new
' exception object using the constructor overload that accepts a
' string message.
adderIL.MarkLabel(failed)
adderIL.Emit(OpCodes.Ldstr, "Cannot accept values over 100 for add.")
adderIL.Emit(OpCodes.Newobj, exCtorInfo)
' We're going to need to refer to that exception object later, so let's
' store it in a temporary variable. Since the store function pops the
' the value/reference off the stack, and we'll need it to throw the
' exception, we will subsequently load it back onto the stack as well.
adderIL.Emit(OpCodes.Stloc_S, tmp2)
adderIL.Emit(OpCodes.Ldloc_S, tmp2)
' Throw the exception currently atop the stack.
adderIL.ThrowException(GetType(OverflowException))
' Start the catch block.
adderIL.BeginCatchBlock(GetType(OverflowException))
' First, we'll load a "wrapper" string, and then perform a
' late-bound call to the ToString() method of OverflowException,
' passing it the exception object we stored in local variable tmp2.
adderIL.Emit(OpCodes.Ldstr, "{0}")
adderIL.Emit(OpCodes.Ldloc_S, tmp2)
adderIL.EmitCall(OpCodes.Callvirt, exToStrMI, Nothing)
' Now, we should have the "wrapper" string atop the stack,
' along with the string result of the ToString() call. All
' conditions are met to call WriteLine(string, object).
adderIL.EmitCall(OpCodes.Call, writeLineMI, Nothing)
' Since our function has to return an integer value, we'll load -1 onto
' the stack to indicate an error, and store it in local variable tmp1.
adderIL.Emit(OpCodes.Ldc_I4_M1)
adderIL.Emit(OpCodes.Stloc_S, tmp1)
' End the exception handling block.
adderIL.EndExceptionBlock()
' The end of the method. If no exception was thrown, the correct value
' will be saved in tmp1. If an exception was thrown, tmp1 will be equal
' to -1. Either way, we'll load the value of tmp1 onto the stack and return.
adderIL.MarkLabel(endOfMthd)
adderIL.Emit(OpCodes.Ldloc_S, tmp1)
adderIL.Emit(OpCodes.Ret)
Return myTypeBldr.CreateType()
End Function 'BuildAdderType
Public Shared Sub Main()
Dim adderType As Type = BuildAdderType()
Dim addIns As Object = Activator.CreateInstance(adderType)
Dim addParams(1) As Object
Console.Write("Enter an integer value: ")
addParams(0) = CType(Convert.ToInt32(Console.ReadLine()), Object)
Console.Write("Enter another integer value: ")
addParams(1) = CType(Convert.ToInt32(Console.ReadLine()), Object)
Console.WriteLine("If either integer was > 100, an exception will be thrown.")
Console.WriteLine("---")
Console.WriteLine("{0} + {1} = {2}", addParams(0), addParams(1), _
adderType.InvokeMember("DoAdd", _
BindingFlags.InvokeMethod, _
Nothing, addIns, addParams))
End Sub 'Main
End Class 'ILThrowExceptionDemo
using System;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
class ILThrowExceptionDemo {
public static Type BuildAdderType() {
AppDomain myDomain = Thread.GetDomain();
AssemblyName myAsmName = new AssemblyName();
myAsmName.Name = "AdderExceptionAsm";
AssemblyBuilder myAsmBldr = myDomain.DefineDynamicAssembly(myAsmName,
AssemblyBuilderAccess.Run);
ModuleBuilder myModBldr = myAsmBldr.DefineDynamicModule("AdderExceptionMod");
TypeBuilder myTypeBldr = myModBldr.DefineType("Adder");
Type[] adderParams = new Type[] {typeof(int), typeof(int)};
// This method will add two numbers which are 100 or less. If either of the
// passed integer vales are greater than 100, it will throw an exception.
MethodBuilder adderBldr = myTypeBldr.DefineMethod("DoAdd",
MethodAttributes.Public |
MethodAttributes.Static,
typeof(int),
adderParams);
ILGenerator adderIL = adderBldr.GetILGenerator();
// representing the offset IL instruction block to branch to.
// These labels, when the MarkLabel(Label) method is invoked,
// will specify the IL instruction to branch to.
ConstructorInfo exCtorInfo = typeof(OverflowException).GetConstructor(
new Type[]
{typeof(string)});
MethodInfo exToStrMI = typeof(OverflowException).GetMethod("ToString");
MethodInfo writeLineMI = typeof(Console).GetMethod("WriteLine",
new Type[]
{typeof(string),
typeof(object)});
LocalBuilder tmp1 = adderIL.DeclareLocal(typeof(int));
LocalBuilder tmp2 = adderIL.DeclareLocal(typeof(OverflowException));
Label failed = adderIL.DefineLabel();
Label endOfMthd = adderIL.DefineLabel();
// First, load argument 0 and the integer value of "100" onto the
// stack. If arg0 > 100, branch to the label "failed", which is marked
// as the address of the block that throws an exception.
Label exBlock = adderIL.BeginExceptionBlock();
adderIL.Emit(OpCodes.Ldarg_0);
adderIL.Emit(OpCodes.Ldc_I4_S, 100);
adderIL.Emit(OpCodes.Bgt_S, failed);
// Now, check to see if argument 1 was greater than 100. If it was,
// branch to "failed." Otherwise, fall through and perform the addition,
// branching unconditionally to the instruction at the label "endOfMthd".
adderIL.Emit(OpCodes.Ldarg_1);
adderIL.Emit(OpCodes.Ldc_I4_S, 100);
adderIL.Emit(OpCodes.Bgt_S, failed);
adderIL.Emit(OpCodes.Ldarg_0);
adderIL.Emit(OpCodes.Ldarg_1);
adderIL.Emit(OpCodes.Add_Ovf_Un);
adderIL.Emit(OpCodes.Stloc_S, tmp1);
adderIL.Emit(OpCodes.Br_S, endOfMthd);
// If one of the arguments was greater than 100, we need to throw an
// exception. We'll use "OverflowException" with a customized message.
// First, we load our message onto the stack, and then create a new
// exception object using the constructor overload that accepts a
// string message.
adderIL.MarkLabel(failed);
adderIL.Emit(OpCodes.Ldstr, "Cannot accept values over 100 for add.");
adderIL.Emit(OpCodes.Newobj, exCtorInfo);
// We're going to need to refer to that exception object later, so let's
// store it in a temporary variable. Since the store function pops the
// the value/reference off the stack, and we'll need it to throw the
// exception, we will subsequently load it back onto the stack as well.
adderIL.Emit(OpCodes.Stloc_S, tmp2);
adderIL.Emit(OpCodes.Ldloc_S, tmp2);
// Throw the exception currently atop the stack.
adderIL.ThrowException(typeof(OverflowException));
// Start the catch block.
adderIL.BeginCatchBlock(typeof(OverflowException));
// First, we'll load a "wrapper" string, and then perform a
// late-bound call to the ToString() method of OverflowException,
// passing it the exception object we stored in local variable tmp2.
adderIL.Emit(OpCodes.Ldstr, "{0}");
adderIL.Emit(OpCodes.Ldloc_S, tmp2);
adderIL.EmitCall(OpCodes.Callvirt, exToStrMI, null);
// Now, we should have the "wrapper" string atop the stack,
// along with the string result of the ToString() call. All
// conditions are met to call WriteLine(string, object).
adderIL.EmitCall(OpCodes.Call, writeLineMI, null);
// Since our function has to return an integer value, we'll load -1 onto
// the stack to indicate an error, and store it in local variable tmp1.
adderIL.Emit(OpCodes.Ldc_I4_M1);
adderIL.Emit(OpCodes.Stloc_S, tmp1);
// End the exception handling block.
adderIL.EndExceptionBlock();
// The end of the method. If no exception was thrown, the correct value
// will be saved in tmp1. If an exception was thrown, tmp1 will be equal
// to -1. Either way, we'll load the value of tmp1 onto the stack and return.
adderIL.MarkLabel(endOfMthd);
adderIL.Emit(OpCodes.Ldloc_S, tmp1);
adderIL.Emit(OpCodes.Ret);
return myTypeBldr.CreateType();
}
public static void Main() {
Type adderType = BuildAdderType();
object addIns = Activator.CreateInstance(adderType);
object[] addParams = new object[2];
Console.Write("Enter an integer value: ");
addParams[0] = (object)Convert.ToInt32(Console.ReadLine());
Console.Write("Enter another integer value: ");
addParams[1] = (object)Convert.ToInt32(Console.ReadLine());
Console.WriteLine("If either integer was > 100, an exception will be thrown.");
Console.WriteLine("---");
Console.WriteLine("{0} + {1} = {2}",
addParams[0], addParams[1],
adderType.InvokeMember("DoAdd",
BindingFlags.InvokeMethod,
null,
addIns,
addParams));
}
}
using namespace System;
using namespace System::Threading;
using namespace System::Reflection;
using namespace System::Reflection::Emit;
Type^ BuildAdderType()
{
AppDomain^ myDomain = Thread::GetDomain();
AssemblyName^ myAsmName = gcnew AssemblyName;
myAsmName->Name = "AdderExceptionAsm";
AssemblyBuilder^ myAsmBldr = myDomain->DefineDynamicAssembly( myAsmName, AssemblyBuilderAccess::Run );
ModuleBuilder^ myModBldr = myAsmBldr->DefineDynamicModule( "AdderExceptionMod" );
TypeBuilder^ myTypeBldr = myModBldr->DefineType( "Adder" );
array<Type^>^adderParams = {int::typeid,int::typeid};
// This method will add two numbers which are 100 or less. If either of the
// passed integer vales are greater than 100, it will throw an exception.
MethodBuilder^ adderBldr = myTypeBldr->DefineMethod( "DoAdd", static_cast<MethodAttributes>(MethodAttributes::Public | MethodAttributes::Static), int::typeid, adderParams );
ILGenerator^ adderIL = adderBldr->GetILGenerator();
// representing the offset IL instruction block to branch to.
// These labels, when the MarkLabel(Label) method is invoked,
// will specify the IL instruction to branch to.
array<Type^>^temp0 = {String::typeid};
ConstructorInfo^ exCtorInfo = OverflowException::typeid->GetConstructor( temp0 );
MethodInfo^ exToStrMI = OverflowException::typeid->GetMethod( "ToString" );
array<Type^>^temp1 = {String::typeid,Object::typeid};
MethodInfo^ writeLineMI = Console::typeid->GetMethod( "WriteLine", temp1 );
LocalBuilder^ tmp1 = adderIL->DeclareLocal( int::typeid );
LocalBuilder^ tmp2 = adderIL->DeclareLocal( OverflowException::typeid );
Label failed = adderIL->DefineLabel();
Label endOfMthd = adderIL->DefineLabel();
// First, load argument 0 and the integer value of S"100" onto the
// stack. If arg0 > 100, branch to the label S"failed", which is marked
// as the address of the block that throws an exception.
Label exBlock = adderIL->BeginExceptionBlock();
adderIL->Emit( OpCodes::Ldarg_0 );
adderIL->Emit( OpCodes::Ldc_I4_S, 100 );
adderIL->Emit( OpCodes::Bgt_S, failed );
// Now, check to see if argument 1 was greater than 100. If it was,
// branch to S"failed." Otherwise, fall through and perform the addition,
// branching unconditionally to the instruction at the label S"endOfMthd".
adderIL->Emit( OpCodes::Ldarg_1 );
adderIL->Emit( OpCodes::Ldc_I4_S, 100 );
adderIL->Emit( OpCodes::Bgt_S, failed );
adderIL->Emit( OpCodes::Ldarg_0 );
adderIL->Emit( OpCodes::Ldarg_1 );
adderIL->Emit( OpCodes::Add_Ovf_Un );
adderIL->Emit( OpCodes::Stloc_S, tmp1 );
adderIL->Emit( OpCodes::Br_S, endOfMthd );
// If one of the arguments was greater than 100, we need to throw an
// exception. We'll use "OverflowException" with a customized message.
// First, we load our message onto the stack, and then create a new
// exception Object using the constructor overload that accepts a
// String* message.
adderIL->MarkLabel( failed );
adderIL->Emit( OpCodes::Ldstr, "Cannot accept values over 100 for add." );
adderIL->Emit( OpCodes::Newobj, exCtorInfo );
// We're going to need to refer to that exception Object later, so let's
// store it in a temporary variable. Since the store function pops the
// the value/reference off the stack, and we'll need it to throw the
// exception, we will subsequently load it back onto the stack as well.
adderIL->Emit( OpCodes::Stloc_S, tmp2 );
adderIL->Emit( OpCodes::Ldloc_S, tmp2 );
// Throw the exception currently atop the stack.
adderIL->ThrowException( OverflowException::typeid );
// Start the catch block.
adderIL->BeginCatchBlock( OverflowException::typeid );
// First, we'll load a "wrapper" String, and then perform a
// late-bound call to the ToString() method of OverflowException,
// passing it the exception Object we stored in local variable tmp2.
adderIL->Emit( OpCodes::Ldstr, " {0}" );
adderIL->Emit( OpCodes::Ldloc_S, tmp2 );
adderIL->EmitCall( OpCodes::Callvirt, exToStrMI, nullptr );
// Now, we should have the "wrapper" String atop the stack,
// along with the String result of the ToString() call. All
// conditions are met to call WriteLine(String*, Object*).
adderIL->EmitCall( OpCodes::Call, writeLineMI, nullptr );
// Since our function has to return an integer value, we'll load -1 onto
// the stack to indicate an error, and store it in local variable tmp1.
adderIL->Emit( OpCodes::Ldc_I4_M1 );
adderIL->Emit( OpCodes::Stloc_S, tmp1 );
// End the exception handling block.
adderIL->EndExceptionBlock();
// The end of the method. If no exception was thrown, the correct value
// will be saved in tmp1. If an exception was thrown, tmp1 will be equal
// to -1. Either way, we'll load the value of tmp1 onto the stack and return.
adderIL->MarkLabel( endOfMthd );
adderIL->Emit( OpCodes::Ldloc_S, tmp1 );
adderIL->Emit( OpCodes::Ret );
return myTypeBldr->CreateType();
}
int main()
{
Type^ adderType = BuildAdderType();
Object^ addIns = Activator::CreateInstance( adderType );
array<Object^>^addParams = gcnew array<Object^>(2);
Console::Write( "Enter an integer value: " );
addParams[ 0 ] = Convert::ToInt32( Console::ReadLine() );
Console::Write( "Enter another integer value: " );
addParams[ 1 ] = Convert::ToInt32( Console::ReadLine() );
Console::WriteLine( "If either integer was > 100, an exception will be thrown." );
Console::WriteLine( "---" );
Console::WriteLine( " {0} + {1} = {2}", addParams[ 0 ], addParams[ 1 ], adderType->InvokeMember( "DoAdd", BindingFlags::InvokeMethod, nullptr, addIns, addParams ) );
}
플랫폼
Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition
.NET Framework에서 모든 플래폼의 모든 버전을 지원하지는 않습니다. 지원되는 버전의 목록은 시스템 요구 사항을 참조하십시오.
버전 정보
.NET Framework
2.0, 1.1, 1.0에서 지원
참고 항목
참조
ILGenerator 클래스
ILGenerator 멤버
System.Reflection.Emit 네임스페이스