Can the "Application Error" Dialog Box Be Disabled

Can the Application Error dialog box be disabled?

1. Use "Disable error reporting", as Mr. Gently suggests. See also this PC World article.
2. If you happen to have MS Visual Studio on your build machine, it will catch Application Errors and pop up a dialog box. To disable these dialogs (and also the Just-In-Time Debugging feature of Visual Studio), run the command drwtsn32.exe -i to set Dr. Watson as the default system debugger. Dr. Watson will generate a core dump and silently exit. (See this Microsoft Knowledge Base article: http://support.microsoft.com/kb/q121434/.)

How do I disable error dialog box in VB.Net

I found the answer! Put in Program.cs (Main file) this code:

Application.SetUnhandledExceptionMode(UnhandledExceptionMode.ThrowException);
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;

(Put it before Application.Run) and ad error handling:

private void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
{
     //TODO: Handle error...
}

How do I disable the dialog box I get when my application errors on exit? Unknown software exception 0xc0020001

The easiest solution is very likely to use SetErrorMode (with - at least - SEM_NOGPFAULTERRORBOX) to shut up any such error dialogs (see the flags in the MSDN docs) and silently have the process terminated.

Another option is to install your own top-level exception handler. In XP and newer you can use vectored exception handling. On any system including those newer ones you can use SetUnhandledExceptionFilter.

Part V, particularly chapter 25, of "Windows via C++" by Richter and Nasarre discusses the topic at great length and detail. The particular topic of WER and top-level exception handlers is also discussed in "Advanced Windows Debugging" (though from a different perspective).

Why do I not see the Application Error dialog box?

Your program has gone off into undefined and erroneous behavior. Why expect exactly the same result on different operating systems?

If something even slightly different happens during the execution on each of those machines, it could plausibly have the result that one hangs while the other immediately crashes.

Perhaps the runtimes that the program is using are slightly different between those machines/operating systems. Perhaps other aspects of the operating system are having an effect (for instance, address space layout randomization).

I suspect only someone with a very intimate knowledge of the runtime and heap manager could answer exactly why there's a difference.

Honestly, my gut reaction to the question is: You shouldn't spend too much time worrying about why the program's failure is different between these two operating systems because you should never write a program like this in the first place.

How to suppress a dialog box displayed by code that I can't change?

A message box pumps a message loop. That's something you can take advantage of, it allows you to inject code with Control.BeginInvoke() that runs as soon as the message box appears. You can then use that code to find the dialog window and close it. Add a new class to your project and paste this code:

using System;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;

public class DialogCloser : IDisposable {
    public DialogCloser() {
        if (Application.OpenForms.Count == 0) throw new InvalidOperationException();
        Application.OpenForms[0].BeginInvoke(new Action(() => {
            // Enumerate windows to find dialogs
            if (cancelled) return;
            EnumThreadWndProc callback = new EnumThreadWndProc(checkWindow);
            EnumThreadWindows(GetCurrentThreadId(), callback, IntPtr.Zero);
            GC.KeepAlive(callback);
        }));
    }

    public void Dispose() {
        cancelled = true;
    }

    private static bool checkWindow(IntPtr hWnd, IntPtr lp) {
        // Checks if <hWnd> is a Windows dialog
        StringBuilder sb = new StringBuilder(260);
        GetClassName(hWnd, sb, sb.Capacity);
        if (sb.ToString() == "#32770") {
            // Close it by sending WM_CLOSE to the window
            SendMessage(hWnd, 0x0010, IntPtr.Zero, IntPtr.Zero);
        }
        return true;
    }

    private bool cancelled;

    // P/Invoke declarations
    private delegate bool EnumThreadWndProc(IntPtr hWnd, IntPtr lp);
    [DllImport("user32.dll")]
    private static extern bool EnumThreadWindows(int tid, EnumThreadWndProc callback, IntPtr lp);
    [DllImport("kernel32.dll")]
    private static extern int GetCurrentThreadId();
    [DllImport("user32.dll")]
    private static extern int GetClassName(IntPtr hWnd, StringBuilder buffer, int buflen);
    [DllImport("user32.dll")]
    private static extern IntPtr SendMessage(IntPtr hWnd, int msg, IntPtr wp, IntPtr lp);
}

Sample usage:

private void button1_Click(object sender, EventArgs e) {
    using (new DialogCloser()) {
        // Replace this with the call to the COM server method:
        MessageBox.Show("you never see this");
    }
}

How to disable pop-up error messages for code editor?

Open Visual Studio, go to Tools->Options...->Text Editor->C#->Advanced and uncheck the Display diagnostics inline (experimental) option.

See attached screenshot:

---

Related Topics