The mystery of the twin exceptions

Question

Here's an interesting question. I have a system that attempts to run some initialization code. If it fails, we call the deinitializer to clean everything up.

Because we call the deinitializer in exception handling, we run the risk that both initialize and deinitialize will fail, and hypothetically, it now seems that we have to throw two exceptions.

It seems pretty unlikely that we will, though. So what happens and what should the code do here?

   try { /* init code here */ }    
   catch (Exception ex)
   {
   try
   {
   _DeinitializeEngine();
   }
   catch (Exception ex2)
   {
   throw new OCRException("Engine failed to initialize; ALSO failed to deinitialize engine!", ex2);
   }
   finally
   {
   throw new OCRException("Engine failed to initialize; failed to initialize license!", ex);
   }
   }

Answer 1

You shouldn't throw in the Finally block. Instead, use the InnerException to add information in the throw.

Update

What you have to do is to catch and rethrow with the "history" of exception, this is done with InnerException. You can edit it when bulding a new exception. This is a code snippet I just wrote to illustrate the idea that I explain in all the comments below.

    static void Main(string[] args)
    {
        try
        {
            principalMethod();
        }
        catch (Exception e)
        {
            Console.WriteLine("Test : " + e.Message);
        }
        Console.Read();
    }

    public static void principalMethod()
    {
        try
        {
            throw new Exception("Primary");
        }
        catch (Exception ex1)
        {
            try
            {
                methodThatCanCrash();
            }
            catch
            {
                throw new Exception("Cannot deinitialize", ex1);
            }
        }
    }

    private static void methodThatCanCrash()
    {
        throw new NotImplementedException();
    }

No need to use double throw with finalize. If you put a break point at the Console.WriteLine(...). You will notice that you have all the exception trace.

Answer 2

If I understand your problem correctly, here's what I would have done:

try { /* init code here */ }            
catch (Exception ex)
{
    // Passing original exception as inner exception
    Exception ocrex = new OCRException("Engine failed to initialize", ex);

    try
    {
        _DeinitializeEngine();
    }
    catch (Exception ex2)
    {
        // Passing initialization failure as inner exception
        ocrex = new OCRException("Failed to deinitialize engine!", ocrex);            
    }
    throw ocrex;
}

Answer 3

If your clean up code is failing and you cannot leave the application in a clean and known state I would let the exception go unhandled (or catch it with the UnhandledException event to log it) then close the application.

Because if you can't handle the first exception, what point is there in catching the second exception?

Answer 4

You have two possible exception conditions: one in which the first method failed, and one in which both methods failed.

You're already defining your own exception class. So create another (or extend the first) with a RelatedException or PriorException property. When you throw the exception in the second case, save a reference to the first exception in this property.

It's up to the exception handler that catches this exception to figure out what to do with the second exception.