Note The CLR considers some exceptions thrown by native code as corrupted state exceptions
(CSEs) because they are usually the result of a bug in the CLR itself or in some native code for
which the managed developer has no control over . By default, the CLR will not let managed code
catch these exceptions and finally blocks will not execute . Here is the list of native Win32
exceptions that are considered CSEs:
EXCEPTION_ACCESS_VIOLATION EXCEPTION_STACK_OVERFLOW
EXCEPTION_ILLEGAL_INSTRUCTION EXCEPTION_IN_PAGE_ERROR
EXCEPTION_INVALID_DISPOSITION EXCEPTION_NONCONTINUABLE_EXCEPTION
EXCEPTION_PRIV_INSTRUCTION STATUS_UNWIND_CONSOLIDATE .
Individual managed methods can override the default and catch these exceptions by applying
the System.Runtime.ExceptionServices.HandleProcessCorruptedStateExceptionsAttribute
to the method . In addition, the method must have the System.Security.
SecurityCriticalAttribute applied to it . You can also override the default for an entire
process by setting the legacyCorruptedStateExceptionPolicy element in the application’s
Extensible Markup Language (XML) configuration file to true . The CLR converts most of these
to a System.Runtime.InteropServices.SEHException object except for EXCEPTION_
ACCESS_VIOLATION, which is converted to a System.AccessViolationException object, and
EXCEPTION_STACK_OVERFLOW, which is converted to a System.StackOverflowException
object .

#include "stdafx.h"
#include "windows.h"

LONG WINAPI MyUnhandledExceptionFilter(
  __in          struct _EXCEPTION_POINTERS* ExceptionInfo
)
{
    printf("Failed\n");
    return EXCEPTION_EXECUTE_HANDLER;

}


int _tmain(int argc, _TCHAR* argv[])
{
    SetErrorMode(SEM_NOGPFAULTERRORBOX);
    SetUnhandledExceptionFilter(MyUnhandledExceptionFilter);
    char* p = NULL;
    *p = 0;
    return 0;
}

PD>#include "stdafx.h"
PD>#include "windows.h"

PD>LONG WINAPI MyUnhandledExceptionFilter(
PD>  __in          struct _EXCEPTION_POINTERS* ExceptionInfo
PD>)
PD>{
PD>    printf("Failed\n");
PD>    return EXCEPTION_EXECUTE_HANDLER;

PD>}


PD>int _tmain(int argc, _TCHAR* argv[])
PD>{
PD>    SetErrorMode(SEM_NOGPFAULTERRORBOX);
PD>    SetUnhandledExceptionFilter(MyUnhandledExceptionFilter);
PD>    char* p = NULL;
PD>    *p = 0;
PD>    return 0;
PD>}


PD>

    [Flags]
    internal enum ErrorModes : uint
    {
        SystemDefault             = 0x0,
        SemFailCriticalErrors     = 0x0001,
        SemNoAlignmentFaultExcept = 0x0004,
        SemNoGpFaultErrorBox      = 0x0002,
        SemNoOpenFileErrorBox     = 0x8000
    }

    internal class SetErrorModeExtern
    {
        [DllImport("kernel32.dll")]
        public static extern ErrorModes SetErrorMode(ErrorModes uMode);
    }

        private static int Main( string[] args )
        {
            SetErrorModeExtern.SetErrorMode( ErrorModes.SemNoGpFaultErrorBox );