Les performances de l'utilisation de méthodes statiques vs l'instanciation de la classe contenant des méthodes

De ici, un appel statique est de 4 à 5 fois plus rapide que la construction d'une instance à chaque fois que vous appelez une méthode d'instance. Cependant, nous sommes encore ne parlons que des dizaines de nanosecondes par appel, de sorte que vous ne remarquez aucun avantage, sauf si vous avez vraiment boucles serrées l'appel d'une méthode des millions de fois, et vous pourriez obtenir le même avantage par la construction d'une instance unique en dehors de cette boucle et en les réutilisant.

Depuis que vous auriez à changer à chaque site d'appel à utiliser la nouvelle méthode statique, vous êtes probablement mieux de passer votre temps à progressivement refactoring.

Ça dépend sur quoi d'autre que l'objet contient -- si "l'objet" est juste un tas de fonctions, alors il est probablement pas la fin du monde. Mais si l'objet contient un tas d'autres objets, puis de l'instanciation, il va appeler tous leurs constructeurs (et les destructeurs, quand il est supprimé) et vous pouvez obtenir une fragmentation de la mémoire et ainsi de suite.

Cela dit, il ne ressemble pas à la performance est votre plus gros problème à l'heure actuelle.

Méthodes statiques sont beaucoup plus rapide et consomme beaucoup moins de mémoire. Il y a cette idée fausse que c'est juste un peu plus vite. Il est un peu plus rapide aussi longtemps que vous ne le mettez pas sur les boucles. BTW, certaines boucles semblent petites, mais ne le sont pas vraiment, car l'appel de la méthode contenant la boucle est également une autre boucle. Vous pouvez faire la différence dans le code qui effectue les fonctions de rendu. Beaucoup moins de mémoire est malheureusement vrai dans de nombreux cas. Un exemple permet de partager facilement des informations avec les autres méthodes. Une méthode statique vous demandera les informations quand il en a besoin.

Mais comme dans la conduite des voitures, de vitesse apporte de la responsabilité. Méthodes statiques ont généralement plus de paramètres que leur instance de contrepartie. Parce qu'une instance devrait prendre soin de la mise en cache des variables partagées, vos méthodes d'instance examinera plus joli.

ShapeUtils.DrawCircle(stroke, pen, origin, radius);

ShapeUtils.DrawSquare(stroke, pen, x, y, width, length);

VS

ShapeUtils utils = new ShapeUtils(stroke,pen);

util.DrawCircle(origin,radius);

util.DrawSquare(x,y,width,length);

Dans ce cas, chaque fois que les variables d'instance sont utilisés par tous les moyens la plupart du temps, les méthodes d'instance sont à peu en vaut la peine. Les Instances ne sont PAS SUR l'ÉTAT, c'est un PARTAGE, bien COMMUN de l'ÉTAT est une forme naturelle de PARTAGE, ils ne sont PAS LES MÊMES. Règle générale: si la méthode est étroitement couplée à d'autres méthodes --- ils s'aiment tellement qu'ils quand on est appelé, l'autre doit être appelé et ils partagent probablement la même tasse d'eau---, il convient d'instance. Pour traduire des méthodes statiques dans les méthodes d'instance n'est pas si difficile que ça. Vous avez seulement besoin de prendre les paramètres partagés et les mettre comme des variables d'instance. L'inverse est plus difficile.

Ou vous pouvez faire une classe proxy qui permettront de combler les méthodes statiques. Bien qu'il peut sembler plus inefficace dans la théorie, la pratique raconte une histoire différente. C'est parce que chaque fois que vous devez appeler un DrawSquare une seule fois ou en boucle), vous accédez directement à la méthode statique. Mais à chaque fois que tu vas l'utiliser sur de et plus long avec DrawCircle, tu vas utiliser l'instance proxy. Un exemple est le Système.IO classes FileInfo (exemple) vs Fichier (statique).

Méthodes statiques sont testables. En fait, même les plus testable que l'instance une fois. Méthode GetSum(x,y) serait très vérifiables, non seulement à l'unité de test, mais de test de charge, intégrée de test et de test d'utilisation. Les méthodes d'Instance sont bonnes pour les unités de tests mais horrible pour tous les autres tests (ce qui est plus important que les unités de tests BTW), c'est pourquoi nous avons tant de bugs ces jours. La chose qui rend TOUTES les Méthodes invérifiables sont des paramètres qui n'ont pas de sens, comme (Expéditeur s, EventArgs e) ou de l'état global comme DateTime.Maintenant. En fait, les méthodes statiques sont si bons à la testabilité que vous voyez moins de bugs dans le code C d'une nouvelle distribution Linux que votre moyenne OO programmeur (il est plein de s***, je le sais).

Il semble ridicule à moi de créer un objet de sorte que vous pouvez appeler une méthode qui apparemment n'a pas d'effets secondaires sur l'objet (à partir de votre description, je suppose que c'). Il me semble que le meilleur compromis serait d'avoir plusieurs objets globaux et il suffit d'utiliser ceux-ci. De cette façon, vous pouvez mettre les variables qui seraient normalement mondial dans les classes appropriées de sorte qu'ils ont légèrement plus petit de la portée.

À partir de là, vous pouvez déplacer lentement à la portée de ces objets pour être de plus en plus petites jusqu'à ce que vous avez une bonne conception de la programmation orientée objet.

Là encore, l'approche que je serait probablement utiliser est différent ;).

Personnellement, j'aurais probablement se concentrer sur les structures et les fonctions qui opèrent sur eux et essayer de les convertir dans les classes avec les membres, peu à peu.

Que pour la performance aspect de la question, les méthodes statiques devrait être légèrement plus rapide (mais pas beaucoup) car ils n'impliquent pas de la construction, en passant et la déconstruction d'un objet.