AsyncLock | Async/Awaitable non-blocking lock in C | Reactive Programming library

You could probably improve upon the first solution by removing a lock from the dictionary when it stops being in use. The removed locks could then be added to a small pool, so that the next time you need a lock you just grab one from the pool instead of creating a new one.

Update: Here is an implementation of this idea. It is based on SemaphoreSlims instead of Stephen Cleary's AsyncLocks, because a custom disposable is required in order to remove unused semaphores from the dictionary.

The access to cache, yes it is thread safe, only one thread per time can read from _cache object.

But in that way you can't assure that all threads gets elements in the same order as they access to GetEnumerator.

Check these two exaples, if the behavior is what you expect, you can use lock in that way.

Example 1:

THREAD1 Calls GetEnumerator

THREAD1 Initialize T current;

THREAD2 Calls GetEnumerator

THREAD2 Initialize T current;

THREAD2 LOCK THREAD

THREAD1 WAIT

THREAD2 read from cache safely _cache[0]

THREAD2 index++

THREAD2 UNLOCK

THREAD1 LOCK

THREAD1 read from cache safely _cache[1]

THREAD1 i++

THREAD1 UNLOCK

THREAD2 yield return current;

THREAD1 yield return current;

Example 2:

THREAD2 Initialize T current;

THREAD2 LOCK THREAD

THREAD2 read from cache safely

THREAD2 UNLOCK

THREAD1 Initialize T current;

THREAD1 LOCK THREAD

THREAD1 read from cache safely

THREAD1 UNLOCK

THREAD1 yield return current;

THREAD2 yield return current;

As Matthew points out in the comments, AsyncLock is reentrant, meaning that if the same thread attempts to take the lock a second time, it recognizes that and allows it to continue. The author of AsyncLock wrote a lengthy article about how reentrance was really the reason he wrote it: AsyncLock: an async/await-friendly locking library for C# and .NET

It's not a bug; it's a feature.™

After the "Update 5/25/2017" heading, there are code examples demonstrating exactly what you are experiencing here and showing how it is a feature.

Reasons to want reentrance are:

1. If you are just concerned with multiple threads touching the same variable (preventing race conditions), then there is simply no reason to block a thread that already has the lock.
2. It makes recursive functions that use locks easier to write because you don't need to test if you already have the lock. A lack of reentrance support + sloppy recursive coding = deadlock.

If you really want it to not be reentrant, you can use what he says was not appropriate for reentrance: SemaphoreSlim:

The lock inside AsyncLock is beeing released very quickly. Each task which tries to acquire AsyncLock, successfully acquires it's internal lock and the actual locking logic is done with a queue.

Python3.6 added support for async generators (PEP525) so async functions can now be generators too!

I can answer one of the two questions.

how to fix this?

I've seen a lot of ReactiveUI projects but never see anyone dispose of ReactiveCommands. The important thing to remember is to dispose of ReactiveCommand subscriptions and bindings.

So if you choose to bind the ReactiveUI way, rather than via xaml, you could do the following in xaml:

Based on the comments it looks like you must use a given repository when the strategy is used either from the web or from an app.

The key here is to avoid trying to guess in which app one is but rather to delegate this responsibility further. This is where dependency injection shines: let the caller give you the correct repository !

First these two repositories have to be grouped under the same abstraction:

Turns out there is a useful nuget library and associated Github repo from Stephen Cleary that is a drop in replacement for the AsyncLock class above.

Change