ConfigureAwait | Configure async code 's ConfigureAwait at a global level | DevOps library

Thanks to @canton7's comment the answer is rather simple: You can prevent the the ExecutionContext from flowing by using ExecutionContext.SuppressFlow.

Corrected above sample:

I most likely discovered by accident that session state disables simultaneous serving of the same endpoint called several times, as devised here:

Disable Session state per-request in ASP.Net MVC

So it appears that it isn't a multithreading problem, instead it's a web app configuration ("by design") problem.

@Richard deeming : Post this as an answer and I'll mark it as the correct one.

The await using syntax currently (C# 10) leaves a lot to be desired, regarding its support for configuring the awaiting of IAsyncDisposables. The best we can do is this:

The T : new() constraint is missing in the calling method’s own generic type.

(At the time of writing, the OP's question is ambiguous as to whether they're referring to HttpRequestMessage or HttpResponseMessage, so I'll describe both).

• HttpRequestMessage.Dispose():
  • Disposes of only the request's Content.
  • See the source code here.
• HttpResponseMessage.Dispose():
  • Disposes of only its response.Content.
  • It does not dispose of response.RequestMessage or the HttpRequestMessage in any other way.
    • It, therefore, does not dispose of the HttpRequestMessage.Content either.
  • See the source code here.

You should not dispose of the HttpRequestMessage until after the HttpClient has fully finished sending your request (I believe there are some (rare) cases where you get a HttpResponseMessage back even if the request's content has not finished being sent yet - like when using exotic transfer-encoding schemes or multi-part requests) - but it's generally best to assume nested lifetimes of all objects involved, so _if System.Net.Http were perfect (which it isn't) then you'd do this:

1. Ensure the request/response is fully completed.
2. Dispose of the response content first.
3. Then the HttpResponseMessage.
4. Then the request's content.
5. Then the HttpRequestMessage.
6. Then the HttpClient.

...however as disposing of content is implicit when you dispose of the parent request/response message (and you probably shouldn't call HttpClient.Dispose either), so just do this:

Docs: await operator (C# reference)

The await operator suspends evaluation of the enclosing async method until the asynchronous operation represented by its operand completes.

After Task taskInstance = ...; await taskInstance;, taskInstance.IsCompleted will always be true.

Possible and working solution is - as silent mentioned - adding the Azure Storage to the Azure API Management. You could add authorization or work with SAS links which might or might not fit your application.

I followed this guide to setup my architecture and it works flawlessly. Thanks to silent for the initial idea.

You could create a list where you randomize the order you want to run things and then call the functions that create the tasks accordingly. For example:

Additional speculation (comes "after" the below historically, but "before" in terms.of things to try) based on my thoughts in a comment: without changing the property at all, you could try adding