Checking whether the current thread owns a lock

Question

Suppose I have the following code:

public class SomeClass()
{
    private readonly object _lock = new object();

    public void SomeMethodA()
    {
        lock (_lock)
        {
            SomeHelperMethod();

            //do something that requires lock on _lock
        }
    }

    public void SomeMethodB()
    {
        lock (_lock)
        {
            SomeHelperMethod();

            //do something that requires lock on _lock
        }
    }

    private void SomeHelperMethod()
    {
        lock (_lock)
        {
            //do something that requires lock on _lock
        }
    }
}

Locking inside SomeHelperMethod seems redundant and wasteful, since all callers have already taken a lock. However, simply removing the lock from SomeHelperMethod seems dangerous since we might later refactor the code and forget to lock the _lock object prior to calling SomeHelperMethod.

Ideally I could work around this by asserting that the current thread owns a lock on _lock inside SomeHelperMethod:

private void SomeHelperMethod()
{
    Debug.Assert(Monitor.HasLock(_lock));

    //do something that requires lock on _lock
}

But there does not appear to be such a method. Monitor.TryEnter does not help because locks are re-entrant. Therefore, if the current thread already owns the lock, TryEnter will still succeed and return true. The only time it will fail is if another thread owns the lock and the call times out.

So, does such a method exist? If not, why? It does not seem dangerous at all to me, since it merely tells you whether the current thread (not another thread) owns a lock or not.

Answer 1

This is supported in .NET 4.5 using Monitor.IsEntered(object).