Why does asynchronous delegate method require calling EndInvoke?

by

The reason you need to call EndInvoke is to avoid memory leaks; .Net will store information about the function’s result (or exception) until you call EndInvoke.

You can call EndInvoke in the completion handler that you give to BeginInvoke and retain the asyncronous nature.

EDIT:

For example: 

class Program {
    private delegate void GenerateXmlDelegate();

    static void Main(string[] args) {
        GenerateXmlDelegate worker = new GenerateXmlDelegate(GenerateMainXml);
        IAsyncResult result = worker.BeginInvoke(delegate {
            try {
                worker.EndInvoke();
            } catch(...) { ... }
        }, null);
    }

    private static void GenerateMainXml() {
        Thread.Sleep(10000);
        Console.WriteLine("GenerateMainXml Called by delegate");
    }
}

If you want to fire an async call and forget about it, you can use the ThreadPool, like this:

ThreadPool.QueueUserWorkItem(delegate { GenerateMainXml(); });

More Related Contents:

  1. Unsubscribe anonymous method in C#
  2. Running multiple async tasks and waiting for them all to complete
  3. Calling async method synchronously
  4. Compiler Ambiguous invocation error – anonymous method and method group with Func or Action
  5. Entity Framework async operation takes ten times as long to complete
  6. Non-blocking file copy in C#
  7. Task sequencing and re-entracy
  8. Calling async methods from a WCF service
  9. Delegates: Predicate vs. Action vs. Func
  10. How do C# Events work behind the scenes?
  11. Wrapping StopWatch timing with a delegate or lambda?
  12. C# 3.0 generic type inference – passing a delegate as a function parameter
  13. Is async/await suitable for methods that are both IO and CPU bound?
  14. Why does the async keyword exist
  15. What thread runs the code after the `await` keyword?
  16. async await return Task
  17. Executing tasks in parallel
  18. Proper way to start and fire-and-forget asynchronous calls?
  19. What is the difference between using and await using? And how can I decide which one to use?
  20. Use Task.Run() in synchronous method to avoid deadlock waiting on async method?
  21. A pattern for self-cancelling and restarting task
  22. How can I capture the value of an outer variable inside a lambda expression?
  23. Keep CurrentCulture in async/await
  24. How do I create a custom SynchronizationContext so that all continuations can be processed by my own single-threaded event loop?
  25. Return a value from an Event — is there a Good Practice for this?
  26. Does Func.BeginInvoke use the ThreadPool?
  27. Using async / await with DataReader ? ( without middle buffers!)
  28. Timeout pattern on task-based asynchronous method in C#
  29. Is it good idea to use “Control.CheckForIllegalCrossThreadCalls = false” [duplicate]
  30. Is it possible to have a delegate as attribute parameter?

Leave a Comment