Difference Between Invoke and DynamicInvoke

by

When you have a delegate instance, you might know the exact type, or you might just know that it is a Delegate. If you know the exact type, you can use Invoke, which is very fast – everything is already pre-validated. For example:

Func<int,int> twice = x => x * 2;
int i = 3;
int j = twice.Invoke(i);
// or just:
int j = twice(i);

However! If you just know that it is Delegate, it has to resolve the parameters etc manually – this might involve unboxing, etc – a lot of reflection is going on. For example:

Delegate slowTwice = twice; // this is still the same delegate instance
object[] args = { i };
object result = slowTwice.DynamicInvoke(args);

Note I’ve written the args long hand to make it clear that an object[] is involved. There are lots of extra costs here:

  • the array
  • validating the passed arguments are a “fit” for the actual MethodInfo
  • unboxing etc as necessary
  • reflection-invoke
  • then the caller needs to do something to process the return value

Basically, avoid DynamicInvoke when-ever you can. Invoke is always preferable, unless all you have is a Delegate and an object[].

For a performance comparison, the following in release mode outside of the debugger (a console exe) prints:

Invoke: 19ms
DynamicInvoke: 3813ms

Code:

Func<int,int> twice = x => x * 2;
const int LOOP = 5000000; // 5M
var watch = Stopwatch.StartNew();
for (int i = 0; i < LOOP; i++)
{
    twice.Invoke(3);
}
watch.Stop();
Console.WriteLine("Invoke: {0}ms", watch.ElapsedMilliseconds);
watch = Stopwatch.StartNew();
for (int i = 0; i < LOOP; i++)
{
    twice.DynamicInvoke(3);
}
watch.Stop();
Console.WriteLine("DynamicInvoke: {0}ms", watch.ElapsedMilliseconds);

More Related Contents:

  1. MethodInvoker vs Action for Control.BeginInvoke
  2. Prevent duplicates from array, based on condition [closed]
  3. Pass Method as Parameter using C#
  4. What’s the difference between Invoke() and BeginInvoke()
  5. Invoke(Delegate)
  6. delegate keyword vs. lambda notation
  7. When & why to use delegates? [duplicate]
  8. Passing variable between winforms
  9. Best Way to Invoke Any Cross-Threaded Code?
  10. How do I Unregister ‘anonymous’ event handler [duplicate]
  11. Performance of calling delegates vs methods
  12. Assigning events in object initializer
  13. Wrapping StopWatch timing with a delegate or lambda?
  14. The purpose of delegates [duplicate]
  15. Invoking methods with optional parameters through reflection
  16. When would you use delegates in C#? [closed]
  17. Are C# events synchronous?
  18. Simple Delegate (delegate) vs. Multicast delegates
  19. How to correctly unregister an event handler
  20. What is Func, how and when is it used
  21. How can I clear event subscriptions in C#?
  22. What are the advantages of delegates? [duplicate]
  23. C# Delegate Instantiation vs. Just Passing the Method Reference [duplicate]
  24. Can’t assign to delegate an anonymous method with less specific parameter type
  25. Does Func.BeginInvoke use the ThreadPool?
  26. Passing a variable between Windows Forms forms
  27. using c# .net libraries to check for IMAP messages from gmail servers [closed]
  28. How to define generic type limit to primitive types?
  29. Properties.Settings.Default.Save(); -> Where is that file
  30. Could not load file or assembly ‘System.Net.Http.Formatting’ or one of its dependencies. The system cannot find the path specified

Leave a Comment