.net core 处理异常的精髓部分

.net core 里面处理异常无论是在linux 或者是widnows都有一个异常入口函数processclrexception()

core里面的异常分为用户异常和硬件异常，前者是代码里面引发的异常，后面是CPU寄存器硬件等引发的异常

两者处理不同在于VEH扩展，当硬件异常的时候，会调用注册的VEH处理异常。而后进入processclrexception,用户异常则省略了VEH部分直接进入

当引发异常的时候，Jithelpers类会调用IL_throw进行处理。然后调用windows api raiseexception抛出异常，通过Windows处理机制进入异常入口函数

这个函数在 linux和windwos上通用，捕捉到异常之后，需要获取异常函数和调用来源，可以通过函数栈来递推循环处理得到来源。当获取到调用的

来源之后，就可以获取core clr 的异常处理，在 .net 里面每个函数都有一个异常处理表。获取到之后，可以枚举异常处理表一次调用 try ,catch ，finally

快的数据。以便处理异常。

IL_Throw 代码如下，主要是引入异常类的对象，然后RaiseTheExceptionInternalOnly函数，在这个函数里了调用了RaiseException(code, flags, argCount, args)，

抛出异常代码，被processclrexception捕捉到。然后流程进入processclrexception。

IL_Throw代码如下：

HCIMPL1(void, IL_Throw, Object* obj)
{
FCALL_CONTRACT;

// This "violation" isn't a really a violation. 
// We are calling a assembly helper that can't have an SO Tolerance contract
CONTRACT_VIOLATION(SOToleranceViolation);
/* Make no assumptions about the current machine state */
ResetCurrentContext();

FC_GC_POLL_NOT_NEEDED(); // throws always open up for GC

HELPER_METHOD_FRAME_BEGIN_ATTRIB_NOPOLL(Frame::FRAME_ATTR_EXCEPTION); // Set up a frame

OBJECTREF oref = ObjectToOBJECTREF(obj);

#if defined(_DEBUG) && defined(_TARGET_X86_)
__helperframe.InsureInit(false, NULL);
g_ExceptionEIP = (LPVOID)__helperframe.GetReturnAddress();
#endif // defined(_DEBUG) && defined(_TARGET_X86_)


if (oref == 0)
COMPlusThrow(kNullReferenceException);
else
if (!IsException(oref->GetMethodTable()))
{
GCPROTECT_BEGIN(oref);

WrapNonCompliantException(&oref);

GCPROTECT_END();
}
else
{ // We know that the object derives from System.Exception
if (g_CLRPolicyRequested &&
oref->GetMethodTable() == g_pOutOfMemoryExceptionClass)
{
EEPolicy::HandleOutOfMemory();
}

// If the flag indicating ForeignExceptionRaise has been set,
// then do not clear the "_stackTrace" field of the exception object.
if (GetThread()->GetExceptionState()->IsRaisingForeignException())
{
((EXCEPTIONREF)oref)->SetStackTraceString(NULL);
}
else
{
((EXCEPTIONREF)oref)->ClearStackTracePreservingRemoteStackTrace();
}
}

#ifdef FEATURE_CORRUPTING_EXCEPTIONS
if (!g_pConfig->LegacyCorruptedStateExceptionsPolicy())
{
// Within the VM, we could have thrown and caught a managed exception. This is done by
// RaiseTheException that will flag that exception's corruption severity to be used
// incase it leaks out to managed code.
//
// If it does not leak out, but ends up calling into managed code that throws,
// we will come here. In such a case, simply reset the corruption-severity
// since we want the exception being thrown to have its correct severity set
// when CLR's managed code exception handler sets it.

ThreadExceptionState *pExState = GetThread()->GetExceptionState();
pExState->SetLastActiveExceptionCorruptionSeverity(NotSet);
}
#endif // FEATURE_CORRUPTING_EXCEPTIONS

//这个函数进入，调用抛出异常

RaiseTheExceptionInternalOnly(oref, FALSE);

HELPER_METHOD_FRAME_END();
}

.Net Core C++ 异常模型

#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <stdio.h>
DWORD scratch;
EXCEPTION_DISPOSITION
__cdecl
processclrexception(struct _EXCEPTION_RECORD* ExceptionRecord,
void* EstablisherFrame,
struct _CONTEXT* ContextRecord,
void* DispatcherContext)
{
unsigned i;
// 指明是我们让流程转到我们的异常处理程序的
printf("Hello from an exception handler
");
// 改变CONTEXT结构中EAX的值，以便它指向可以成功进写操作的位置
ContextRecord->Eax = (DWORD)&scratch;
// 告诉操作系统重新执行出错的指令
return ExceptionContinueExecution;
}
int main()
{
DWORD handler = (DWORD)processclrexception
__asm
{
// 创建EXCEPTION_REGISTRATION结构：
push handler // handler函数的地址
push FS : [0] // 前一个handler函数的地址
mov FS : [0] , ESP // 安装新的EXECEPTION_REGISTRATION结构
}
RaiseException(EXCEPTION_ACCESS_VIOLATION
, EXCEPTION_NONCONTINUABLE, 0, NULL);
//__asm
//{
// mov eax, 0 // 将EAX清零
// mov[eax], 1 // 写EAX指向的内存从而故意引发一个错误
//}
printf("After writing!
");
__asm
{
// 移去我们的EXECEPTION_REGISTRATION结构
mov eax, [ESP] // 获取前一个结构
mov FS : [0] , EAX // 安装前一个结构
add esp, 8 // 将我们的EXECEPTION_REGISTRATION弹出堆栈
}
return 0;

}

下面是ProcessCLRException，这个函数非常长，长达几千行，只贴出部分有用的

ProcessCLRException(IN PEXCEPTION_RECORD pExceptionRecord
WIN64_ARG(IN ULONG64 MemoryStackFp)
NOT_WIN64_ARG(IN ULONG MemoryStackFp),
IN OUT PCONTEXT pContextRecord,
IN OUT PDISPATCHER_CONTEXT pDispatcherContext
)
{

DWORD   dwLastError     = GetLastError();//获取到当前的执行结果

ExceptionTracker* pTracker = ExceptionTracker::GetOrCreateTracker( // 这个函数里面会实例化一个异常的托管类，比如ExceptionArgument类等。
pDispatcherContext->ControlPc,
sf,
pExceptionRecord,
pContextRecord,
bAsynchronousThreadStop,
!(dwExceptionFlags & EXCEPTION_UNWINDING),
&STState);

status = pTracker->ProcessOSExceptionNotification( // 这个函数会调用 .net core里面的 异常的try块的代码
pExceptionRecord,
pContextRecord,
pDispatcherContext,
dwExceptionFlags,
sf,
pThread,
STState
#ifdef USE_PER_FRAME_PINVOKE_INIT
, (PVOID)pICFSetAsLimitFrame
#endif // USE_PER_FRAME_PINVOKE_INIT
);

ClrUnwindEx(pExceptionRecord,// 这个函数调用了 windows api RtlUnwindEx 。RtlUnwindEx第二次调用ExceptionHandler，执行展开操作，清理资源等
(UINT_PTR)pThread,
INVALID_RESUME_ADDRESS,
pDispatcherContext->EstablisherFrame);

// .net core里面的异常try 块被执行了，如果有finally ,在这里会被执行。调用了windwos api RtlRestoreContext(pContextRecord, pExceptionRecord);执行finally 块

ExceptionTracker::ResumeExecution(pContextRecord,pExceptionRecord);

                                              NULL

                                              );

}

以上就是大致的.net core 异常处理流程。有疑问可以一起交流 QQ群：676817308