ILGenerator.BeginFaultBlock Método
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Inicia um bloco de falha de exceção no fluxo de MSIL (Microsoft Intermediate Language).
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 ()
A MSIL sendo gerada ainda não está em um bloco de exceção.
- ou -
Este ILGenerator pertence a outro DynamicMethod.
O exemplo de código a seguir ilustra o uso de 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
Se o atual ILGenerator estiver associado a um DynamicMethod objeto , não há suporte para a emissão de blocos de falha de exceção. DynamicILInfo pode ser usado para construir um método dinâmico que usa blocos de falha de exceção.
Produto | Versões |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 2.0 (package-provided), 2.1 |
Comentários do .NET
O .NET é um projeto código aberto. Selecione um link para fornecer comentários: