I have a version that seems to work with Recursion. It works with AsyncLocal and therefore can only work if there always is a AsyncStateMachine present when used. In my case this can be ensured. Maybe this could also be ensured in general. If the AsyncReaderWriterLock itself enforces this it would be possible.

At the moment I work with the mentioned workaround for UpgradeableReadLock. But I would really like to use this with AsyncEx.

My solution is something like:

private int lockScope;
private Random rand = new();
static AsyncLocal<int> _asyncLocalScope = new AsyncLocal<int>();

public IDisposable WriterLock(CancellationToken cancellationToken)
{
    return RequestWriterLockAsync(cancellationToken, Environment.CurrentManagedThreadId).GetAwaiter().GetResult();
}

public AwaitableDisposable<IDisposable> WriterLockAsync(CancellationToken cancellationToken)
{
    var lockScope = _asyncLocalScope.Value;
    if(lockScope == 0){
        lockScope = rand.Next();
        _asyncLocalScope.Value = lockScope;
    }
    return new AwaitableDisposable<IDisposable>(RequestWriterLockAsync(cancellationToken, lockScope));
}

private Task<IDisposable> RequestWriterLockAsync(CancellationToken cancellationToken, int lockScope)
{
    Task<IDisposable> ret;
    lock (this)
    {
        // If the lock is available, take it immediately.
        if (_locksHeld == 0)
        {
            _locksHeld = -1;
#pragma warning disable CA2000 // Dispose objects before losing scope
            ret = Task.FromResult<IDisposable>(new WriterKey(this));
#pragma warning restore CA2000 // Dispose objects before losing scope
            this.lockScope = lockScope;
        }
        else if (_locksHeld < 0 && this.lockScope == lockScope)
        {
            --_locksHeld;
#pragma warning disable CA2000 // Dispose objects before losing scope
            ret = Task.FromResult<IDisposable>(new WriterKey(this));
#pragma warning restore CA2000 // Dispose objects before losing scope
        }
        else
        {
            // Wait for the lock to become available or cancellation.
            ret = higherlevel.Enqueue(this, cancellationToken, lockScope);
        }
    }

    ReleaseWaitersWhenCanceled(ret);
    return ret;
}

If RequestWriterLockAsync was async then you could guarantee that there is a AsyncStateMachine. Do you think there is any significant downside in doing that?

Uh oh!

Feature request: AsyncReaderWriterLock support for UpgradeableReadLock #280

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions