Discussion :

[zouuc]

Bonjour,

je vais avoir pour objectif prochainement de rendre plus performant du code (du moins, réduire le temps d'exécution d'un programme en C#) et je fais des recherches.

J'apprends pas mal de chose sur ce langage, et je souhaiterais savoir par exemple ;

- Si la définition d'une méthode Méthode() (ayant le même nom), dans plusieurs classes différentes, nécessite un "virtual" pour la première et "override" pour les autres, pour optimiser le code (faciliter l'exécution et donc en réduire le temps).

- Si il existe aussi une manipulation pour écrire le temps d'exécution (du programme bien sure) en terme de milliseconde en C# sur console ou sur un fichier de logging par exemple.
Edit => j'ai trouvé ça pour le temps :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
Stopwatch stopw = new Stopwatch(); 
//Démarrage du chrono 
stopw.Start(); 
 
/* Le code dont on veut mesurer le temps d'exécution. 
 * Cela peut être du code brut ou des appels de méthodes... */ 
 
//Arrêt du chorno 
stopw.Stop(); 
//On récupère la durée écoulé, en millisecondes 
long milliseconds = stopw.ElapsedMilliseconds; 
//ou encore, dans un format TimeSpan 
TimeSpan ts = stopw.Elapsed;

Merci d'avance.

[meziantou]

Si il existe aussi une manipulation pour écrire le temps d'exécution (du programme bien sure) en terme de milliseconde en C# sur console ou sur un fichier de logging par exemple.

Tu peux utiliser un profiler, par exemple DotTrace. Il y en a d'autres que tu trouvera grace à google.

[zouuc]

Merci

Pour le moment comme dis plus haut (avec un Edit)
j'ai trouvé StopWatch pour le temps, j'ai donc fais une batterie de test, et étrangement lorsque que j'utilise :

public virtual void MaMethode() pour une première méthode.
ET
public override void MaMethode() pour une deuxième méthode ayant le même nom que la première.

Je fais ça sur une exécution en boucle d'un million de d'exécutions. Et ça met plus de temps en règle général qu'avec la technique qui consiste en :

public void MaMethode() pour la première
ET
public new void MaMethode() pour la seconde.

Bien sur je fais appel aux deux méthodes dans les exécutions.

Donc quelle est vraiment l'utilité du virtual et du override en terme de rapidité d'exécution ? (à moins que j'ai mal compris comment les utiliser, ce qui peut aussi se poser).

[theMonz31]

salut

à moins que tu fasses bcp de boucles d'1 millions d'itérations, chercher ce genre d'optimisation, c'est inutile.

Améliorer les performances d'un code s'est avant tout améliorer le chargement des données, l'accès à ces données (un dictionnaire étant plus rapide qu'une liste à partir d'une certaine taille, etc...)..

Après, t'as tjs le classique StringBuilder à la place du String pour concaténer (mais là encore, les gains sont "minimes" en fonction de la quantité de traitement)...

Avant de regarder celà, il vaudrait mieux (mais peut-etre est-ce déja fait regarder la gueule globale du code, de l'architecture, etc...

Ah oui, l'utilisation des mécanismes de reflection (par exemple, pour faire des plugs-in, et autre, Interface, etc..) coute pas mal cher quand meme en .Net

[zouuc]

Merci à toi theMonz31

Je me renseigne sur le mécanisme de réflexion.

En effet, tester de manière aussi brutale un tel nombre d'exécutions ( sur un programme réalisé en 5 minutes ) ne me permet sans doute pas de tester les réelles capacités de ce code (qui, je l'avoue aussi ne représente pas grand chose de concret).

Je viens de débuter un stage en informatique, et comme ma vraie mission n'a pas encore commencée, je me renseigne sur son sujet ^^.

Merci à vous en tous cas.

[Thorna]

Le couple virtual/override est plus long et c'est normal: la véritable méthode à exécuter est déterminée à l'exécution quand le vrai type de la variable est connu, pas à la compilation. Et donc ça rallonge l'exécution.

[cinemania]

thorna, oui mais c'est indispensable dans le cadre d'un héritage et lorsque l'on souhaite avoir recours à une classe ancêtre comme modèle, et pour la covariance et contravariance.

je dirais dans l'absolu, que si les héritières n'ont pas besoin du code ancêtre, et que les méthodes sont radicalement opposées, le mieux est encore d'avoir des noms différents ou d'utiliser le new dans l'héritière... bien que là il faudrait tester avec reflector ce que le compilateur génère comme code IL lors d'un appel à cette méthode, par rapport au code généré pour un appel à une méthode "override".

de toute façon, le fait de ne pas avoir recours à de la liaison dynamique, n'est qu'une question de nanosecondes, et ce n'est pas ce genre de paramètre qui prime lorsque l'on cherche à optimiser du code.
Il y a souvent d'autres paramètres à prendre en considération en amont.

Tout d'abord utiliser un Profiler de code permet de savoir où se situe les goulets d'étranglements, et les zones "critiques" qui prennent du temps.
De là, il peut être intéressant de les retoucher, et de revoir les algorithmes, et éventuellement en dernier recours l'architecture sous-jacente.

Effectivement s'il y a des appels de méthode par la reflexion, il faut proscrire cela, car cela coute très cher en temps il faut alors utiliser les délégates ou les lambda (compilation) ou pour finir la LCG.