How to gracefully get out of AbandonedMutexException?

Question

I use the following code to synchronize mutually exclusive access to a shared resource between several running processes.

The mutex is created as such:

Mutex mtx = new Mutex(false, "MyNamedMutexName");

Then I use this method to enter mutually exclusive section:

public bool enterMutuallyExclusiveSection()
{
    //RETURN: 'true' if entered OK, 
    //         can continue with mutually exclusive section
    bool bRes;

    try
    {
        bRes = mtx.WaitOne();
    }
    catch (AbandonedMutexException)
    {
        //Abandoned mutex, how to handle it?

        //bRes = ?
    }
    catch
    {
        //Some other error
        bRes = false;
    }

    return bRes;
}

and this code to leave it:

public bool leaveMutuallyExclusiveSection()
{
    //RETURN: = 'true' if no error
    bool bRes = true;

    try
    {
        mtx.ReleaseMutex();
    }
    catch
    {
        //Failed
        bRes = false;
    }

    return bRes;
}

But what happens is that if one of the running processes crashes, or if it is terminated from a Task Manager, the mutex may return AbandonedMutexException exception. So my question is, what is the graceful way to get out of it?

This seems to work fine:

    catch (AbandonedMutexException)
    {
        //Abandoned mutex
        mtx.ReleaseMutex();
        bRes = mtx.WaitOne();    
    }

But can I enter the mutually exclusive section in that case?

Can someone clarify?

Solution

According to MSDN the AbandonedMutexException is:

The exception that is thrown when one thread acquires a Mutex object that another thread has abandoned by exiting without releasing it.

This means that the thread in which this exception was thrown is the new owner of the Mutex (otherwise calling the Mutex.ReleaseMutex Method like you're doing would trigger an ApplicationException), and if you can assure the integrity of the data structures protected by the mutex you can simply ignore the exception and continue executing your application normally.

However, most of the times the AbandonedMutexException is raised the integrity of the data structures protected by the mutex cannot be guaranteed, and that's why this exception was introduced in the version 2.0 of the .NET framework:

An abandoned mutex indicates a serious programming error. When a thread exits without releasing the mutex, the data structures protected by the mutex might not be in a consistent state. Prior to version 2.0 of the .NET Framework, such problems were hard to discover because no exception was thrown if a wait completed as the result of an abandoned mutex.

Comments

[c00000fd]

You know, I tried it out and it doesn't raise any exceptions. Still, shall I call mtx.WaitOne() again?

[Thomas C. G. de Vilhena]

No, it's not necessary to call WaitOne again because the Mutex was already acquire by the thread that caught the AbandonedMutexException.

[Thomas C. G. de Vilhena]

You're welcome. I just added some more info from MSDN to the answer ;)