Fix Threading hanging with NeoSystem

[cschuchardt88]

Description

using Wait() on a thread is bad and blocks syncing thread context like in debugging.

Type of change

• Optimization (the change is only an optimization)
• Style (the change is only a code style for better maintenance or standard purpose)
• Bug fix (non-breaking change which fixes an issue)
• New feature (non-breaking change which adds functionality)
• Breaking change (fix or feature that would cause existing functionality to not work as expected)
• This change requires a documentation update

How Has This Been Tested?

• Unit Testing

Checklist:

• My code follows the style guidelines of this project
• I have performed a self-review of my code
• I have commented my code, particularly in hard-to-understand areas
• I have made corresponding changes to the documentation
• My changes generate no new warnings
• I have added tests that prove my fix is effective or that my feature works
• New and existing unit tests pass locally with my changes
• Any dependent changes have been merged and published in downstream modules

[vncoelho]

I think that both locks the thread until task is completed, no?

The difference is that now it throws the original exception directly (not wrapped such as AggregateException).

[cschuchardt88]

I think that both locks the thread until task is completed, no?

The difference is that now it throws the original exception directly (not wrapped such as AggregateException).

The code GetAwaiter().GetResult() is commonly used in C# to synchronously block and wait for the completion of an asynchronous operation (like a Task or Task<T>) while also propagating exceptions in a way that's often preferred for debugging

Here's a breakdown:

• GetAwaiter(): This method retrieves an object called an awaiter from the asynchronous operation. The awaiter is responsible for managing the asynchronous process and its completion.
• GetResult(): This method on the awaiter blocks the calling thread until the asynchronous operation is finished. It then returns the result of the operation if it was successful, or throws an exception if it failed.

Why and when might you use it?

While the await keyword is generally the preferred way to handle asynchronous operations in C#, GetAwaiter().GetResult() can be used in specific situations where you need to:

• Synchronously wait for an asynchronous operation: When you can't mark a method as async (e.g., in a constructor), but need to wait for an asynchronous operation to complete, this approach can be employed.
• Handle exceptions directly: Unlike Task.Wait or Task.Result, which can wrap exceptions in an AggregateException, GetAwaiter().GetResult() rethrows the original exception directly. This can make it easier to catch and handle specific exceptions during debugging.
• Run asynchronous code in a non-async context: You can use this method to execute an asynchronous method and wait for its completion synchronously.

Important Considerations:

• Potential for deadlocks: Using GetAwaiter().GetResult() can potentially lead to deadlocks, especially in scenarios involving SynchronizationContext. The best practice is to avoid blocking on asynchronous code unless absolutely necessary.
• Use Task.Run().GetAwaiter().GetResult() to avoid deadlocks: If you need to synchronously wait for an async operation in a situation where a SynchronizationContext is involved, using Task.Run().GetAwaiter().GetResult() can prevent deadlocks.
• Use with ConfigureAwait(false): When using GetAwaiter().GetResult(), it's recommended to call ConfigureAwait(false) on the asynchronous operation to avoid capturing the current SynchronizationContext and potentially preventing deadlocks.

In essence, getawaiter().getresult() allows you to take control of how an asynchronous operation is awaited and how exceptions are handled, but it comes with potential risks and should be used with caution and careful consideration of its implications for your application's concurrency and thread management.

[Jim8y]

This pr achieved what it intends to, and fixed the potential issue, thus LGTM.

[superboyiii]

This avoid deadlock and get expection correctly.