AsyncEx | A helper library for async/await | Reactive Programming library

In short, you have dependencies on two different versions of the same DLL. Breakdown below, but TL;DR, you should be able to resolve this by updating your PackageReference to System.Runtime.CompilerServices.Unsafe to version 6.0.0.

If you don't call into it directly, consider removing the PackageReference, as it should be added transitively via the other references listed below.

If you don't have a PackagerReference to this package, adding one (using version 6.0.0) would make that the primary reference, thereby again aligning everything at the same version.

Error message breakdown:

I now believe that this is the same as Return Task or Await Questions and therefore Rene's answer there will be correct

poorly summarized here as -- bit more overhead in await for the compiler, but basically the same at runtime.

This isn't something that can be done with wrapping the tasks before blocking. For starters, if the requests go through, you may end up nuking the server. Right now you're nuking the client. There's a 2 concurrent-request per domain limit in .NET Framework that can be relaxed, but if you set it too high you may end up nuking the server.

You can solve this by using DataFlow blocks in a pipeline to execute requests with a fixed degree of parallelism and then parse them. Let's say you have a class called MyPayload with lots of Items in a property:

Don't change your SeedTestData method. Because it's responsible for seed your test data. You don't need to add TenantTestDataBuilder to seed your tenant-related data. It's also responsible for that too.

Looks like channels is what you're looking for.

An Introduction to System.Threading.Channels

Working with Channels in .NET

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.

What I think happens is that after calling GetAsync the continuation cannot switch back to the same thread since the other thread is waiting for the continuation to start. Does the following code work?