Conditions when finally does not execute in a .net try..finally block

Question

Basically I've heard that certain conditions will cause .net to blow past the finally block. Does anyone know what those conditions are?

score 54 · Accepted Answer · edited Mar 10 '13 at 18:32

54

Two possibilities:

The finally block will not be executed when there's a StackOverflowException since there's no room on the stack to even execute any more code. It will also not be called when there's an ExecutionEngineException, which may arise from a call to Environment.FailFast().

edited Mar 10 '13 at 18:32

Gabriel

1,433
14
23

answered Sep 21 '08 at 18:23

Haacked

56,299
14
88
112

4

Perhaps worth noting that ExecutingEngineException may arise from a call to Environment.FailFast() – Daniel Fortunov Jan 11 '10 at 11:55
3

B.T.W. I think it should be ExecutionEngineException instead of ExecutingEngineException? – Wiebe Tijsma Feb 09 '12 at 13:57
I am getting a __COM Context for this RuntimeCallableWraper failed__ error similar as described in https://stackoverflow.com/questions/36768352/transition-into-com-context-for-this-runtimecallablewrapper-failed-error-in-pa only I am using LINQ to SQL
This doesn't seems to be an exception in the usual manner and doesn't execute the __finally__ block we have in place.
Has anyone seen this error before and can confirm if it does not execute the __finally__ block? – Luke T O'Brien Sep 30 '17 at 09:31
Seems so the same goes for [InvalidProgramException](https://docs.microsoft.com/en-us/dotnet/api/system.invalidprogramexception?view=net-5.0). – Yarl Jun 18 '21 at 09:26

score 15 · Answer 2 · answered Sep 21 '08 at 18:21

15

Unless the CLR blows up and goes down with an ExecutingEngineException (I've seen a few in the .net 1.1 days with just the right amount of COM Interop :) .. I think finally should always execute.

answered Sep 21 '08 at 18:21

Gishu

130,964
46
219
301

Chris · Answer 3 · 2008-09-21T18:37:10.563

You can get a situation where the code in the try block causes a SecurityException to be thrown before the try block entered (instead the exception is thrown when the containing method is called (see http://msdn.microsoft.com/en-us/library/fk6t46tz(VS.71).aspx)), in this situation you never even enter the try block so the code in the finally block is never called.

Other possibilities include StackOverflowException, and ExecutingEngineException.

score 4 · Answer 4 · edited Dec 08 '16 at 12:29

Finally block on background thread may not execute. However, It depends upon the completed execution of main foreground thread which terminates background thread operation even before the complete execution of background thread.

class Program
{

    static void Main(string[] args)
    {
        Program prgm = new Program();
        Thread backgroundThread = new Thread(prgm.CheckBgThread);
        backgroundThread.IsBackground = true;
        backgroundThread.Start();
        Console.WriteLine("Closing the program....");
    }

    void CheckBgThread()
    {
        try
        {
            Console.WriteLine("Doing some work...");
            Thread.Sleep(500);
        }
        finally
        {
            Console.WriteLine("This should be always executed");
        }
    }
}

score 2 · Answer 5 · answered Dec 20 '08 at 20:29

2

There is also Application.Exit method.

answered Dec 20 '08 at 20:29

2

You mean `Environment.Exit`. `Application.Exit` allows the main routine to continue, so I'm sure `Finally` blocks are executed. – Mark Hurd Feb 15 '12 at 13:37

score 1 · Answer 6 · answered Jun 05 '20 at 14:05

Since async/await, there is another way a finally might get ignored that I haven't seen mentioned in other answers:

static class Program
{
    [STAThread]
    static void Main()
    {
        async void ThreadExecutionAsync()
        {
            try
            {
                SynchronizationContext.SetSynchronizationContext(
                    new WindowsFormsSynchronizationContext());

                await Task.Yield(); // Yield to the context

                // The WindowsFormsSynchronizationContext will schedule the continuation
                // on the main thread, so the current thread will die
                // and we will never get here...
                Debugger.Break();
            }
            finally
            {
                // Will never get here either...
                Debugger.Break();
            }
        }

        var thread = new Thread(ThreadExecutionAsync);
        thread.Start();

        Application.Run();
    }
}

score 0 · Answer 7 · answered Sep 21 '11 at 20:03

Neither code which follows a finally block, nor code in outer scopes, will execute without the finally block having been started first (an exception within the finally block may cause it to exit prematurely, in which case execution will jump out from the finalizer to an outer scope). If code prior to the finally block gets stuck in an endless loop or a method that never exits, or if the execution context is destroyed altogether, the finally block will not execute.

Note that it is proper to rely upon finally blocks, unlike "Finalize" methods (or C# "destructors") which should not properly be relied upon.

Conditions when finally does not execute in a .net try..finally block

7 Answers7

Linked

Related