Question

we’re having an application on server instance and quite rarely, but we have out of memory exception (program is not leaking, just instance is quite small and it operates with quite big amounts of data).

That would be not a problem, as we monitor processes on that server instance and if some of the processes are not found in process list, alert email is sent.

Now the problem is with this:

That prevents process from disappearing from process list, so we don’t get alert email about it’s failure. Is it possible to disable this message, that if program fails on something we don’t catch, it would close without user interaction?

Answer 1

Assuming Windows Forms, I typically do multiple steps to prevent this message box.

First, I connect several handlers in the Main function:

[STAThread]
private static void Main()
{
    Application.ThreadException +=
        application_ThreadException;

    Application.SetUnhandledExceptionMode(
        UnhandledExceptionMode.CatchException);

    AppDomain.CurrentDomain.UnhandledException +=
        currentDomain_UnhandledException;

    Application.Run(new MainForm());
}

Those handlers are being called when an otherwise unhandled exception occurs. I would define them something like:

private static void application_ThreadException(
    object sender,
    ThreadExceptionEventArgs e)
{
    doHandleException(e.Exception);
}

private static void currentDomain_UnhandledException(
    object sender,
    UnhandledExceptionEventArgs e)
{
    doHandleException(e.ExceptionObject as Exception);
}

The actual doHandleException function that is then called does the actual error handling. Usually this is logging the error and notifying the user, giving him the options to continue the application or quit it.

An example from a real-world application looks like:

private static void doHandleException(
    Exception e)
{
    try
    {
        Log.Instance.ErrorException(@"Exception.", e);
    }
    catch (Exception x)
    {
        Trace.WriteLine(string.Format(
                @"Error during exception logging: '{0}'.", x.Message));
    }

    var form = Form.ActiveForm;
    if (form == null)
    {
        MessageBox.Show(buildMessage(e), 
                "MyApp", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
    else
    {
        MessageBox.Show(form, buildMessage(e), 
                "MyApp", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
}

With the helper function:

public static string buildMessage(Exception exception)
{
    var result = new StringBuilder();

    while (exception != null)
    {
        result.AppendLine(exception.Message);
        result.AppendLine();
        exception = exception.InnerException;
    }

    return result.ToString().Trim();
}

If you are using not Windows Forms but e.g. a Console application or WPF, some handlers are not present, while others are present instead.

The idea stays the same: Subscribe to event handlers that are being called if you have no try...catch around your code blocks.

Personally, I try to have as few of those try...catch blocks as possible (ideally none).