La Performance du “direct” virtuel appel contre appel d'interface en C#

Je pense que l'article à http://msdn.microsoft.com/en-us/magazine/cc163791.aspx répondra à vos questions. En particulier, voir la section Interface Vtable de la Carte et de la Carte d'Interface, et la section suivante sur Virtuel de l'Expédition.

Il est probablement possible de le compilateur JIT pour comprendre les choses et d'optimiser le code de votre cas simple. Mais pas dans le cas général.

IFoo f2 = GetAFoo();

Et GetAFoo est définie comme le retour d'un IFoo, alors le compilateur JIT de ne pas être en mesure d'optimiser l'appel.

OriginalL'auteur Jim Mischel

J'ai essayé votre test et sur ma machine, dans un contexte particulier, le résultat est en fait l'inverse.

Je suis sous Windows 7 x64 et j'ai créé un Visual Studio 2010 projet d'Application Console dans lequel j'ai copié ton code. Si un compiler le projet en mode Debug et avec la plate-forme cible comme x86 la sortie sera la suivante:

Appel Direct: 48.38

Par le biais de l'interface: 42.43

En fait à chaque fois lors de l'exécution de l'application, il fournira des résultats légèrement différents, mais l'interface des appels sera toujours plus rapide. Je suppose que, puisque l'application est compilée en tant que x86, il sera exécuté par le système d'exploitation par le biais de WOW.

Pour une référence complète, ci-dessous sont les résultats pour le reste de la configuration de la compilation et de la cible combinaisons.

Libération mode et x86 cible

Appel Direct: 23.02

Par le biais de l'interface: 32.73

Debug mode et x64 cible

Appel Direct: 49.49

Par le biais de l'interface: 56.97

Libération mode et x64 cible

Appel Direct: 19.60

Par le biais de l'interface: à 26,45

Tous les tests ci-dessus ont été effectués .Net 4.0 en tant que plate-forme cible pour le compilateur. Lors de la commutation à 3,5 et de répéter les tests ci-dessus, les appels par le biais de l'interface ont été toujours plus de temps que les appels directs.

Donc, les tests ci-dessus plutôt compliquer les choses, puisqu'il semble que le comportement que vous repéré n'est pas toujours le cas.

À la fin, avec le risque de déplaire, je voudrais ajouter quelques réflexions. De nombreuses personnes ont ajouté des commentaires que les différences de performances sont assez petites et dans le monde réel de la programmation vous ne devriez pas vous soucier d'eux et je suis d'accord avec ce point de vue. Il y a deux raisons principales à cela.

La première et la plus annoncé l'une est que .Net a été de construire sur un niveau plus élevé afin de permettre aux développeurs de se concentrer sur l'augmentation des niveaux d'applications. Une base de données ou un service externe d'appel est à des milliers ou parfois des millions de fois plus lent que le virtuel appel de méthode. Avoir une bonne architecture de haut niveau et en se concentrant sur la grande performance de consommateurs apportera toujours de meilleurs résultats dans des applications modernes plutôt que d'éviter la double-pointeur-déréférence.

La deuxième et plus obscur, c'est que l' .Net de l'équipe par la construction d'un cadre d'un niveau supérieur, a en effet introduit une série de niveaux d'abstraction qui le juste à temps compilateur serait en mesure de l'utiliser pour faire des optimisations sur les différentes plates-formes. Le plus accès qu'ils voulaient donner à la sous-couches les plus de développeurs seraient en mesure d'optimiser votre site pour une plate-forme spécifique, mais le moins que l'exécution du compilateur serait en mesure de faire pour les autres. C'est la théorie, au moins, et c'est pourquoi les choses ne sont pas aussi bien documenté que dans C++ au sujet de cette question en particulier.

OriginalL'auteur Florin Dumitrescu

La règle générale est: les Classes sont rapides. Les Interfaces sont lents.

C'est une des raisons de la recommandation "de Construire des hiérarchies de classes et d'utiliser les interfaces pour les échanges intra-hiérarchie de comportement".

Pour les méthodes virtuelles, la différence peut sembler minime (de l'ordre de 10%). Mais pour les non-virtuel, de méthodes et de champs, la différence est énorme. Considérons ce programme.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace InterfaceFieldConsoleApplication
{
class Program
{
public abstract class A
{
public int Counter;
}
public interface IA
{
int Counter { get; set; }
}
public class B : A, IA
{
public new int Counter { get { return base.Counter; } set { base.Counter = value; } }
}
static void Main(string[] args)
{
var b = new B();
A a = b;
IA ia = b;
const long LoopCount = (int) (100*10e6);
var stopWatch = new Stopwatch();
stopWatch.Start();
for (int i = 0; i < LoopCount; i++)
a.Counter = i;
stopWatch.Stop();
Console.WriteLine("a.Counter: {0}", stopWatch.ElapsedMilliseconds);
stopWatch.Reset();
stopWatch.Start();
for (int i = 0; i < LoopCount; i++)
ia.Counter = i;
stopWatch.Stop();
Console.WriteLine("ia.Counter: {0}", stopWatch.ElapsedMilliseconds);
Console.ReadKey();
}
}
}

De sortie:

a.Counter: 1560
ia.Counter: 4587

OriginalL'auteur Johan Nilsson