AspNetCoreDiagnosticScenarios

It should be pointed out, that the main reason they didn't go further was because of added complexity in .NET, when async/await already exists. > Green threads introduce a completely new async programming model. The interaction between green threads and the existing async model is quite complex for .NET developers. For example, invoking async methods from green thread code requires a sync-over-async code pattern that is a very poor choice if the code is executed on a regular thread. Also to note that even the current model is complex enough to warrant a FAQ, https://devblogs.microsoft.com/dotnet/configureawait-faq https://github.com/davidfowl/AspNetCoreDiagnosticScenarios/b...

Important: following #prefer-asyncawait-over-directly-returning-task from https://github.com/davidfowl/AspNetCoreDiagnosticScenarios/b... is not correct. The concerns raised are niche and edge case and task must always be forwarded as is provided there is no post-processing or resource cleanup with idisposable. I wish Mr. Fowl had more time to modernize the guide and remove other snippets that are no longer recommended like creating long-running tasks. (it is more efficient, and threadpool can perfectly cope with it, to just moderately block the worker threads when no other option is available, and nowadays there are better tools like Channel<T> over BlockingCollection<T>)

No it doesn't, hence why there are best practices guidelines written by the .NET architects, and there was a research project to add Go/Java co-routines as well. https://github.com/davidfowl/AspNetCoreDiagnosticScenarios/b... https://twitter.com/davidfowl/status/1532880744732758018?lan... https://github.com/dotnet/runtimelab/issues/2057 https://github.com/dotnet/runtimelab/issues/2398

This one? https://github.com/davidfowl/AspNetCoreDiagnosticScenarios/b...

Here, https://github.com/davidfowl/AspNetCoreDiagnosticScenarios/b... https://github.com/dotnet/runtimelab/issues/2398

They don't work just fine in C#, there is a reason why one of ASP.NET architects has written a guide of best practices. https://github.com/davidfowl/AspNetCoreDiagnosticScenarios/b... Ironically, C++'s design is heavily related to C#, as the initial proposal was done by Microsoft and shares many of the same ideas, including how to create runtime aware awaitable types.

Many that praise async/await in C#, kind of forget it took about 10 years to spread across all the layer of the language and runtime, since it was done via IL rewriting, it caused several issues with F# async tasks, due to the age of the ecosystem plenty of code isn't async/await friendly and needs to be wrapped into Task.Run() or similar. There is a best practices guideline from one of the ASP.NET architects, https://github.com/davidfowl/AspNetCoreDiagnosticScenarios/b... During last year they researched adding Go/Java's approach to .NET, but now it is too late. See the ASP.NET Q&A session at BUILD 2023.

And yet it didn't learn that it took almost 10 years for .NET community to sort out async/await support across all layers of the stack. .NET archictects have spent last year researching Go and Java Loom approaches, and have acknowledge if it had been today, most likely that would have been the approach taken instead of async/await, as many .NET devs still get it wrong. During the "ASP.NET Core and Blazor futures, Q&A" at BUILD 2023. This is the best practices of async/await in .NET as written by one of the ASP.NET architects, https://github.com/davidfowl/AspNetCoreDiagnosticScenarios/b...

To expand upon this thought, here is the AsyncGuidance doc[1] on why not to use .Result to get the return value of a completed Task in C#. To make this simple they introduced async Main[2] a few years ago. [1]: https://github.com/davidfowl/AspNetCoreDiagnosticScenarios/b... [2]: https://github.com/dotnet/csharplang/blob/main/proposals/csh...

I have the conclusion opt-in async/await is a mistake. I think high level language/runtime like c# should handle it automatically like it is a sync call but a way to opt-out should be still possible. In my career, 99% of the time my code awaited async calls. I remember one case we tried to run tasks parallel, but the client for DB(ravendb) started throwing exceptions, possible race condition. Also, they did terrible work when it was first introduced, low level details were leaked to app surface and it was impossible to comprehend for a regular programmer what the hell is going on? Do you remember ConfigureAwait(false)? Years later such guidance compiled: https://github.com/davidfowl/AspNetCoreDiagnosticScenarios/b...

FYI, if you plan to do this in ASP netcore, combine with AsyncLazy for the most optimal results https://github.com/davidfowl/AspNetCoreDiagnosticScenarios/b...

Unfortunately, there are problems with both of those approaches: https://github.com/davidfowl/AspNetCoreDiagnosticScenarios/b... I don't know if it extends to other language implementations, but C# does not seem to have a reliable sync-over-async story.