Différence Entre les Invoquer et de DynamicInvoke

Lorsque vous avez un délégué exemple, vous pouvez connaître le type exact, ou vous pourriez juste savoir que c'est un Delegate. Si vous connaissez le type exact, vous pouvez utiliser Invoke, qui est très rapide - tout est déjà pré-validés. Par exemple:

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

Cependant! Si vous savez juste qu'il est Delegate, il a à régler les paramètres etc manuellement, cela peut impliquer des unboxing, etc - beaucoup de réflexion est en cours. Par exemple:

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

Remarque j'ai écrit le args long de la main pour indiquer clairement qu'un object[] est impliqué. Il y a beaucoup de frais supplémentaires ici:

• le tableau
• valider les arguments passés sont un "ajustement" pour le MethodInfo
• unboxing etc comme nécessaire
• réflexion invoquer
• ensuite, l'appelant doit faire quelque chose pour traiter la valeur de retour

En gros, éviter de DynamicInvoke quand vous le pouvez. Invoke est toujours préférable, à moins que vous ne disposez que d'un Delegate et un object[].

Pour une comparaison de performances, la suivante en mode de diffusion à l'extérieur du débogueur (une console exe) imprime:

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);