C# ReaderWriterLockSlim Best Practice to Avoid Recursion

Question

I have a class using ReaderWriterLockSlim with a read method and a write method that uses the read method to retrieve the element to be modified. A quick example would be:

class FooLocker
{
    ReaderWriterLockSlim locker = new ReaderWriterLockSlim();
    List<Foo> fooList = new List<Foo>();

    public void ChangeFoo(int index, string bar)
    {
        locker.EnterWriteLock();

        try
        {
            Foo foo = GetFoo(index);
            foo.Bar = bar;
        }
        finally
        {
            locker.ExitWriteLock();
        }
    }

    public Foo GetFoo(int index) 
    {
        locker.EnterReadLock(); //throws System.Threading.LockRecursionException

        try
        {
            return fooList[index];
        }
        finally
        {
            locker.ExitReadLock();
        }
    }

    //snipped code for adding instances etc.
}

As above, this code throws a LockRecursionException when calling ChangeFoo() because a write lock is already held when GetFoo() tries to enter a read lock.

I've checked the documentation for ReaderWriterLockSlim and I can use LockRecursionPolicy.SupportsRecursion to allow the above to work. However, the documentation also recommends that this shouldn't be used for any new development and should only be used when upgrading existing code.

Given this, what is the best practice to achieve the same result where a write method can use a read-only method to retrieve the thing that needs to be modified?

Answer 1

You can divide your class up into exposed methods and private inner methods. The inner methods do the logic like fetching and the public methods perform the locking. Example:

class FooLocker 
{ 
    ReaderWriterLockSlim locker = new ReaderWriterLockSlim(); 
    List<Foo> fooList = new List<Foo>(); 


    public void ChangeFoo(int index, string bar) 
    { 
        locker.EnterWriteLock(); 

        try 
        { 
            Foo foo = UnsafeGetFoo(index); 
            foo.Bar = bar; 
        } 
        finally 
        { 
            locker.ExitWriteLock(); 
        } 
    } 

    public Foo GetFoo(int index)  
    { 
        locker.EnterReadLock();  

        try 
        { 
            return UnsafeGetFoo(index);
        } 
        finally 
        { 
            locker.ExitReadLock(); 
        } 
    } 

    private Foo UnsafeGetFoo(int index)
    {
        return fooList[index]; 
    }
}