VS2010 does not show unhandled exception message in a WinForms Application on a 64-bit version of Windows

Question

When I create a new project, I get a strange behavior for unhandled exceptions. This is how I can reproduce the problem:

1) create a new Windows Forms Application (C#, .NET Framework 4, VS2010)

2) add the following code to the Form1_Load handler:

int vara = 5, varb = 0;
int varc = vara / varb;
int vard = 7;

I would expect that VS breaks and shows an unhandled exception message at the second line. However, what happens is that the third line is just skipped without any message and the application keeps running.

I don't have this problem with my existing C# projects. So I guess that my new projects are created with some strange default settings.

Does anyone have an idea what's wrong with my project???

I tried checking the boxes in Debug->Exceptions. But then executions breaks even if I handle the exception in a try-catch block; which is also not what I want. If I remember correctly, there was a column called "unhandled exceptions" or something like this in this dialog box, which would do excatly what I want. But in my projects there is only one column ("Thrown").

Blowup

same problem here! Form load already catches excpetions internally.. – Obliteration

Answer 1

This is a nasty problem induced by the wow64 emulation layer that allows 32-bit code to run on the 64-bit version of Windows 7. It swallows exceptions in the code that runs in response to a notification generated by the 64-bit window manager, like the Load event. Preventing the debugger from seeing it and stepping in. This problem is hard to fix, the Windows and DevDiv groups at Microsoft are pointing fingers back and forth. DevDiv can't do anything about it, Windows thinks it is the correct and documented behavior, mysterious as that sounds.

It is certainly documented but just about nobody understands the consequences or thinks it is reasonable behavior. Especially not when the window procedure is hidden from view of course, like it is in any project that uses wrapper classes to hide the window plumbing. Like any Winforms, WPF or MFC app. Underlying issue is Microsoft could not figure out how to flow exceptions from 32-bit code back to the 64-bit code that triggered the notification back to 32-bit code that tries to handle or debug the exception.

It is only a problem with a debugger attached, your code will bomb as usual without one.

Project > Properties > Build tab > Platform target = AnyCPU and untick Prefer 32-bit. Your app will now run as a 64-bit process, eliminating the wow64 failure mode. Some consequences, it disables Edit + Continue for VS versions prior to VS2013 and might not always be possible when you have a dependency on 32-bit code.

Other possible workarounds:

• Debug > Exceptions > tick the Thrown box for CLR exceptions to force the debugger to stop at the line of code that throws the exception.
• Write try/catch in the Load event handler and failfast in the catch block.
• Use Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException) in the Main() method so that the exception trap in the message loop isn't disabled in debug mode. This however makes all unhandled exceptions hard to debug, the ThreadException event is pretty useless.
• Consider if your code really belongs in the Load event handler. It is very rare to need it, it is however very popular in VB.NET and a swan song because it is the default event and a double-click trivially adds the event handler. You only ever really need Load when you are interested in the actual window size after user preferences and autoscaling is applied. Everything else belongs in the constructor.
• Update to Windows 8 or later, they have this wow64 problem solved.

Phonate

do you have a reference for this bug? Connect article, maybe? – Grappling

Yes, there's a Connect article for it. Lots of them. This one is probably best: connect.microsoft.com/VisualStudio/feedback/details/357311/… – Phonate

And here's one that suggests they don't have much of a clue what's going on: connect.microsoft.com/VisualStudio/feedback/details/589858/… – Phonate

thanks for the links. I suppose it would be "piling on" if I voted for these. – Grappling

I'm working with Win7 64-Bit, but the target was set to x86 by default. – Blowup

I have checked this same bug exists on a Winforms application, on the OnFormClosed event. And I cannot solve it changing the app target to x86 also. But at least I have a problem explanation. – Uranic

Another workaround seems to be Application.ThreadException. Setting it seems to help - the exceptions are triggered in the IDE and by the debugger. – Ethiopian

@HansPassant, I'd like to know what you think about my answer below. – Sequestration

@Jon - yup, that's described in the last link I posted. Not entirely sure if changing the code is the best way, it is a debug-time problem only. It will however work, as long as you catch the exception you'll get on an older version of Windows. – Phonate

@HansPassant ah, didn't see that. Also, I don't understand why a) this (seemingly) only happens with a debugger attached, and b) they were suddenly able to make it work with this hotfix. – Sequestration

It is because running with a debugger disables the normal exception handler that catches the exception and raises the ThreadException event. Before Windows can swallow it. – Phonate

Not to mention, it doesn't always work. I put that code in the application I was actually working on when I noticed this, and it simply exited, instead of showing the exception in the debugger. Hmmph. – Sequestration

Windows 8 do have this problem. Just FYI. – Miracidium

How about calling the Load handler from within a try block that includes an exception filter? A breakpoint on the filter will trip before any stack unwinding occurs; I'm not sure how to make the cursor show where the exception occurred, but one single-stepping through finally cleanup blocks should give a clue. – Yeomanly

This answer is wrong. Setting Platform Target to "Any CPU" (or "x64" for that matter) does NOT solve the problem; not entirely, at least. The app will stop and you will get a "Program Compatibility Assistant" popup, but it still doesn't let you use the debugger normally. – Trump

Answer 2

In my experience, I only see this issue when I'm running with a debugger attached. The application behaves the same when run standalone: the exception is not swallowed.

With the introduction of KB976038, you can make this work as you'd expect again. I never installed the hotfix, so I'm assuming it came as part of Win7 SP1.

This was mentioned in this post:

• The case of the disappearing OnLoad exception – user-mode callback exceptions in x64

Here's some code that will enable the hotfix:

public static class Kernel32
{
    public const uint PROCESS_CALLBACK_FILTER_ENABLED = 0x1;

    [DllImport("Kernel32.dll")]
    public static extern bool SetProcessUserModeExceptionPolicy(UInt32 dwFlags);

    [DllImport("Kernel32.dll")]
    public static extern bool GetProcessUserModeExceptionPolicy(out UInt32 lpFlags);


    public static void DisableUMCallbackFilter() {
        uint flags;
        GetProcessUserModeExceptionPolicy(out flags);

        flags &= ~PROCESS_CALLBACK_FILTER_ENABLED;
        SetProcessUserModeExceptionPolicy(flags);
    }
}

Call it at the beginning of your application:

    [STAThread]
    static void Main()
    {
        Kernel32.DisableUMCallbackFilter();

        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new Form1());
    }

I've confirmed (with the the simple example shown below) that this works, just as you'd expect.

protected override void OnLoad(EventArgs e) {
    throw new Exception("BOOM");   // This will now get caught.
}

So, what I don't understand, is why it was previously impossible for the debugger to handle crossing kernel-mode stack frames, but with this hotfix, they somehow figured it out.

Sequestration

Set/GetProcessUserModeExceptionPolicy are still not documented on MSDN, and Kernel32.dll of Windows 8 does not export them. – Neurosurgery

Isn't there a way to do the same thing by editing the registry or something? – Miracidium

I have read them. I also read the comment that windows 8 kernel do not export these methods. I happen to run on windows 8. I was just asking, just in case. – Miracidium

If you apply the hotfix you point to, you can solve the problem by editing the registry, as they describe, instead of using the methods. I remember having solved that problem on a Win7 machine, this way, before. Unfortunately, you cannot do that in Win 8. – Miracidium

@Miracidium Thanks for pointing that out. I guess I shouldn't be commenting past my bedtime :-) – Sequestration

Answer 3

As Hans mentions, compile the application and run the exe without a debugger attached.

For me the problem was changing a Class property name that a BindingSource control was bound to. Running without the IDE I was able to see the error:

Cannot bind to the property or column SendWithoutProofReading on the DataSource. Parameter name: dataMember

Fixing the BindingSource control to bind to the updated property name resolved the problem:

Michail

Answer 4

I'm using WPF and ran into this same problem. I had tried Hans 1-3 suggestions already, but didn't like them because studio wouldn't stop at where the error was (so I couldn't view my variables and see what was the problem).

So I tried Hans' 4th suggestion. I was suprised at how much of my code could be moved to the MainWindow constructor without any issue. Not sure why I got in the habit of putting so much logic in the Load event, but apparently much of it can be done in the ctor.

However, this had the same problem as 1-3. Errors that occur during the ctor for WPF get wrapped into a generic Xaml exception. (an inner exception has the real error, but again I wanted studio to just break at the actual trouble spot).

What ended up working for me was to create a thread, sleep 50ms, dispatch back to main thread and do what I need...

    void Window_Loaded(object sender, RoutedEventArgs e)
    {
        new Thread(() =>
        {
            Thread.Sleep(50);
            CrossThread(() => { OnWindowLoaded(); });
        }).Start();
    }
    void CrossThread(Action a)
    {
        this.Dispatcher.BeginInvoke(a);
    }
    void OnWindowLoaded()
    {
        ...do my thing...

This way studio would break right where an uncaught exception occurs.

Fess

Answer 5

A simple work-around could be if you can move your init code to another event like as Form_Shown which called later than Form_Load, and use a flag to run startup code at first form shown:

bool firstLoad = true; //flag to detect first form_shown

private void Form1_Load(object sender, EventArgs e)
{
    //firstLoad = true;
    //dowork(); //not execute initialization code here (postpone it to form_shown)
}

private void Form1_Shown(object sender, EventArgs e)
{
    if (firstLoad) //simulate Form-Load
    {
        firstLoad = false;

        dowork();
    }
}

void dowork()
{
    var f = File.OpenRead(@"D:\NoSuchFile756.123"); //this cause an exception!

}

Hypothesize