Скачать или смотреть Improving Performance with Asynchronous Delegates in the Modern .NET World

Discover how to enhance your .NET applications by refactoring `Asynchronous Delegates` into more modern and maintainable solutions while maintaining performance.
---
This video is based on the question https://stackoverflow.com/q/74893090/ asked by the user 'JhonMalk199' ( https://stackoverflow.com/u/11116245/ ) and on the answer https://stackoverflow.com/a/74894007/ provided by the user 'Stephen Cleary' ( https://stackoverflow.com/u/263693/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Asynchronous delegates: performance in modern .NET world

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Improving Performance with Asynchronous Delegates in the Modern .NET World

When developing applications in .NET, many of us find ourselves grappling with legacy code. A common stumbling block arises from the use of Asynchronous Delegates, which might have sufficed in the past but now raises questions about performance and maintainability. If you've inherited a legacy project filled with asynchronous delegate patterns, you might be wondering: is it time to refactor?

In this guide, we will explore the implications of using asynchronous delegates in modern .NET development and consider alternative approaches that could offer both performance improvements and code maintainability.

The Legacy of Asynchronous Delegates

The code snippet below illustrates a typical use of asynchronous delegates:

[[See Video to Reveal this Text or Code Snippet]]

And for parameterless calls, you might see something like this:

[[See Video to Reveal this Text or Code Snippet]]

While this approach may have served its purpose in the past, modern applications are evolving. You might be wondering if migrating to newer patterns could lead to performance enhancements.

Evaluating the Alternatives

You are considering whether to transition from asynchronous delegate calls to one of the following alternatives:

ThreadPool.QueueUserWorkItem for parameterless calls.

BackgroundWorker to report progress to GUI (as your GUI currently subscribes to events in asynchronous code).

Async/Await patterns, which are commonly favored in contemporary C- development.

Let's weigh these options against the use of asynchronous delegates.

1. Performance Gains: Are They Significant?

The short answer is that switching from Delegate.BeginInvoke to the alternatives listed above may not yield significant performance gains. While the differences in functionality and performance can vary depending on the use case, here are some important factors to consider:

Task Parallelism: The .NET Task Parallel Library (TPL), used with async and await, can manage multiple threads more effectively than traditional approaches, leading to improved scalability in certain scenarios.

Overhead: While there may be shifts in performance, the computation overhead introduced by handling asynchronous mechanisms may balance out the perceived benefits, especially if the legacy codebase is functioning adequately.

2. Maintainability: A Strong Argument

One compelling reason to refactor is maintainability. Modern techniques (specifically, the async/await pattern) offer:

Readability: Code written with async and await is generally easier to understand and maintain, typically resembling synchronous code while being asynchronous.

Error Handling: It simplifies traditional error handling, making it easier to write robust applications.

3. Portability: Moving Forward with .NET

Another key argument for transitioning is portability. If you plan to migrate from the .NET Framework to .NET Core, you'll discover that Delegate.BeginInvoke is not supported in .NET Core. By refactoring now, you prepare your project for future transitions, which also often bring performance benefits.

Recommendations for Refactoring

If you decide to move away from Delegate.BeginInvoke, consider utilizing Task.Run for modern code patterns:

[[See Video to Reveal this Text or Code Snippet]]

This approach:

Enables thread-safe execution.

Integrates seamlessly with the async/await paradigm, making it versatile for both background operations and UI thread updates.

Conclusion

In an ever-evolving development landscape, time-tested practices, such as asynchronous delegates, may not be the best choices for new or modernized applications. It is prudent to focus on