Supposons que nous avons une classe A qui implémente une interface IC# méthode Invoke Classe/Interface (code natif, coût)
I i = new A();
i.method(); // example 1
A a = (A)i;
a.method() // example 2
Le code IL généré pour chaque appel à "méthode()" est le même, mais lequel des invocations à la méthode "méthode()" a plus de coût en code natif et pourquoi?
Toute aide sera appréciée.
Généralement, l'appel à ((A)a).method() sera (encore un peu) plus rapide, car le compilateur JIT connaît (statiquement) la méthode concrète qui devrait être appelée, et peut donc appeler directement A.method. L'appel à travers l'interface I nécessite une vérification de l'exécution sur le type réel de l'objet vers lequel pointe la référence, puis l'envoi à cette implémentation. Je n'ai pas de références pour ça, cependant.
Je sais que le compilateur JIT Java a obtenu quelques optimisations à cet égard, comme chaque appel de méthode est virtuel - il devine & caches la mise en œuvre la plus utilisée d'une méthode d'interface particulière et optimise pour ce cas. Le .NET JIT n'en a pas autant besoin, car les méthodes doivent être explicitement virtuelles.
Ceci est beaucoup un cas de micro-optimisation que vous ne devriez vraiment pas vous inquiéter.
Si le code IL est le même, le (coût du) code natif le sera également. Pourquoi le JIT les traite-t-il différemment?
Cela a du sens, merci. – aumanets