Techniques d’optimisation en C #

Je me demande quel genre de techniques d’optimisation on utilise souvent de nos jours. J’ai vu des gens faire la mise en cache tout le temps avec le dictionnaire et tout. Est-ce que l’espace commercial pour la vitesse est le seul moyen d’y aller?

Les algorithmes posent aussi souvent des problèmes, généralement lorsque quelque chose de coûteux est effectué dans une boucle. Généralement, la première chose à faire est de profiler votre application, ce qui vous indiquera la ou les parties les plus lentes de celle-ci. Généralement, ce que vous faites pour accélérer votre application dépend de ce que vous trouvez. Par exemple, si votre application imite un système de fichiers, il se peut que vous appeliez la firebase database de manière récursive pour remonter l’arborescence (par exemple). Vous pouvez optimiser ce cas en modifiant ces appels récursifs en un seul appel de firebase database aplatie qui renvoie toutes les données en un seul appel.

Encore une fois, la réponse est, comme toujours, «ça dépend». Cependant, vous trouverez plus d’exemples et de conseils sur le blog de Rico Mariani (parcourez quelques années en arrière, car son objective a changé):

Vraiment, c’est votre choix d’algorithmes. Habituellement, il n’y a pas de solution miracle pour l’optimisation.

Par exemple, l’utilisation d’un SsortingngBuilder au lieu d’une concaténation peut accélérer considérablement votre code, mais il existe un compromis. Si vous ne concaténez pas d’énormes jeux de chaînes, la mémoire et le temps nécessaires pour initialiser SsortingngBuilder sont pires que l’utilisation d’une concaténation normale. Il existe de nombreux exemples dans le cadre, tels que la mise en cache du dictionnaire, comme vous l’avez mentionné dans votre question.

La seule optimisation générale que vous puissiez réellement apprendre et appliquer à votre codage tout au long de votre journée est la performance de Boxing / Unboxing (tas vs stack). Pour ce faire, vous devez apprendre de quoi il s’agit et comment éviter ou réduire le besoin de le faire.

La documentation MSDN de Microsoft contient 2 articles sur les performances qui donnent beaucoup de bonnes techniques d’usage général (ce ne sont en réalité que des versions différentes du même article).

Dépend de beaucoup de choses, vraiment.

Par exemple, lorsque la mémoire devient un problème et que de nombreux objects temporaires sont créés, j’ai tendance à utiliser des pools d’objects. (Avoir un ramasse-miettes n’est pas une raison pour ne pas s’occuper de l’allocation de mémoire). Si la vitesse est ce qui compte, je pourrais utiliser des pointeurs non sécurisés pour travailler avec des tableaux.

Quoi qu’il en soit, si vous vous trouvez trop aux sockets avec des techniques d’optimisation dans l’application ac # /. Net, vous avez probablement choisi le mauvais langage / la mauvaise plate-forme.

Je vais suggérer ci-dessous

1. Savoir quand utiliser SsortingngBuilder

Vous devez avoir déjà entendu dire qu’un object SsortingngBuilder est beaucoup plus rapide pour append des chaînes ensemble que des types de chaîne normaux.

The thing is SsortingngBuilder is faster mostly with big ssortingngs. This means if you have a loop that will add to a single ssortingng for many iterations then a SsortingngBuilder class is definitely much faster than a ssortingng type. However if you just want to append something to a ssortingng a single time then a SsortingngBuilder class is overkill. A simple ssortingng type variable in this case improves on resources use and readability of the C# source code.

En choisissant simplement correctement entre les objects SsortingngBuilder et les types de chaîne, vous pouvez optimiser votre code.

2. Comparaison de chaînes non sensibles à la casse

Dans une application, il est parfois nécessaire de comparer deux variables de chaîne en ignorant les cas. L’approche tentante et traditionnelle consiste à convertir les deux chaînes en minuscules ou en majuscules, puis à les comparer, comme ceci:

str1.ToLower() == str2.ToLower()

Cependant, l’appel répété de la fonction ToLower () est un goulot d’étranglement dans performace. En utilisant plutôt la fonction intégrée ssortingng.Compare (), vous pouvez augmenter la vitesse de vos applications.

Pour vérifier si deux chaînes sont égales, la casse ignorée ressemblerait à ceci:

ssortingng.Compare(str1, str2, true) == 0 //Ignoring cases

La fonction ssortingng.Compare en C # renvoie un entier égal à 0 lorsque les deux chaînes sont égales.

3. Utilisez ssortingng.Empty

Il ne s’agit pas tant d’une amélioration des performances que d’une amélioration de la lisibilité, mais cela compte quand même comme une optimisation du code. Essayez de remplacer des lignes comme:

if (str == "")

avec:

if (str == ssortingng.Empty)

Il s’agit simplement d’une meilleure pratique de programmation et n’a pas d’impact négatif sur les performances.

Remarque: il est de pratique courante de vérifier que la longueur d’une chaîne est égale à 0 est plus rapide que de la comparer à une chaîne vide. Cela aurait pu être vrai une fois que ce n’est plus une amélioration significative des performances. Au lieu de cela, restz avec ssortingng.Empty.

4. Remplacer ArrayList par List <>

ArrayList est utile lors du stockage de plusieurs types d’objects dans la même liste. Toutefois, si vous conservez le même type de variables dans une seule ArrayList, vous pouvez améliorer vos performances en utilisant plutôt les objects List <>.

Prenez la liste de tableaux suivante:

 ArrayList intList = new ArrayList(); intList.add(10); return (int)intList[0] + 20; 

Notez qu’il ne contient que des entiers. L’utilisation de la classe List> est bien meilleure. Pour le convertir en une liste typée, seuls les types de variable doivent être modifiés:

 List intList = new List(); intList.add(10) return intList[0] + 20; 

Il n’est pas nécessaire de convertir les types avec List <>. L’augmentation des performances peut être particulièrement significative avec les types de données primitifs tels que les entiers.

5. Utilisez && et || les opérateurs

Lors de la construction des instructions if, veillez simplement à utiliser les doubles et notation (&&) et / ou les doubles (||) (en Visual Basic, il s’agit de AndAlso et OrElse).

Si les instructions qui utilisent & et | doit vérifier chaque partie de la déclaration puis appliquer le “et” ou “ou”. Par contre, && et || parcourez les déclarations une à la fois et arrêtez-vous dès que la condition est remplie ou non.

L’exécution de moins de code est toujours un avantage en termes de performances, mais elle peut également éviter les erreurs d’exécution, considérez le code C # suivant:

 if (object1 != null && object1.runMethod()) 

Si object1 est null, avec l’opérateur &&, object1.runMethod () ne sera pas exécuté. Si l’opérateur && est remplacé par &, object1.runMethod () s’exécutera même si la valeur de l’object object1 est déjà nulle, ce qui provoque une exception.

6. Smart Try-Catch

Les instructions Try-Catch sont conçues pour intercepter les exceptions qui sont hors du contrôle des programmeurs, telles que la connexion au Web ou à un périphérique, par exemple. Utiliser une instruction try pour garder le code “simple” au lieu d’utiliser des instructions if pour éviter les appels sujettes aux erreurs rend le code incroyablement plus lent. Restructurez votre code source pour exiger moins d’instructions try.

7. Remplacer les divisions

C # est relativement lent en ce qui concerne les opérations de division. Une solution consiste à remplacer les divisions par une opération de multiplication-décalage pour optimiser davantage C #. L’article explique en détail comment effectuer la conversion.

RÉFÉRENCE

En général, assurez-vous de bien comprendre la complexité temporelle de différents algorithmes et utilisez ces connaissances pour choisir judicieusement vos implémentations.

Pour .NET en particulier, cet article explique en détail l’optimisation du code déployé sur le CLR (bien qu’il soit également pertinent pour Java ou toute autre plate-forme moderne) et constitue l’un des meilleurs guides que j’ai jamais lus:

http://msdn.microsoft.com/en-us/library/ms973852.aspx

Pour résumer l’article en une phrase: Rien n’affecte davantage la vitesse d’une application .NET (avec des algorithmes sensibles) que l’empreinte mémoire de ses objects. Veillez à minimiser votre consommation de mémoire.

Je recommanderais Effective C # de Bill Wagner ( première édition et deuxième édition ). Il passe en revue un certain nombre de constructions et de techniques langagières et explique lesquelles sont les plus rapides et pourquoi. Il aborde également de nombreuses pratiques exemplaires.

Cependant, le plus souvent, l’optimisation de votre algorithme vous donnera de bien meilleurs résultats que l’utilisation de tout type de technique de langage / d’optimisation.