La vitesse d'exécution du logiciel doit se situer dans une plage acceptable pour l'utilisateur. Souvent, l’amélioration de la vitesse de ces routines éphémères mais fréquemment utilisées augmentera considérablement la vitesse globale du logiciel.
Bien entendu, pour améliorer la vitesse, il faut d’abord être capable de mesurer le temps. Bon, alors considérons la situation sur la piste. Dès que le pistolet retentit, appuyez sur le chronomètre pour démarrer le chronométrage, et terminez le chronométrage lorsque le joueur atteint la ligne d'arrivée. À ce moment-là, vous pouvez connaître le temps utilisé par le joueur. . Avant de commencer le tour suivant, le chronomètre doit être remis à zéro. .NET2.0 fournit également un tel chronomètre : la classe Chronomètre, qui peut mesurer le temps avec plus de précision.
Test de vitesse :
Les performances et la testabilité des logiciels sont un sujet complexe. S'assurer qu'une application répond aux attentes des utilisateurs nécessite de prendre en compte ses performances et sa testabilité pendant le cycle de développement. Ceci est crucial lors de la phase de conception, une mauvaise conception entraînera presque certainement une mauvaise expérience utilisateur. Cependant, une bonne conception ne garantit pas à elle seule que le programme fonctionnera efficacement. La qualité du code final est tout aussi importante.
Mesurer une routine de longue durée est assez simple. Si un processus dure plusieurs minutes, une montre peut être utilisée pour enregistrer l'heure. Par exemple, pour un processus dont l’exécution prend deux minutes, une amélioration de 10 % peut faire gagner 12 secondes, ce qui est facile à déterminer.
Et si vous souhaitez mesurer un processus à très court terme, vous devez envisager une meilleure précision. Par exemple, il existe de très petites routines qui ne prennent qu'un millième de seconde à s'exécuter, mais qui seront appelées 1 million de fois. L'effet cumulatif est évident. Dans les versions précédentes du framework .NET, vous deviez utiliser les fonctions de l'API Windows, et dans le framework .NET 2.0, Microsoft a introduit la classe Chronomètre (c'est notre chronomètre) pour simplifier les tâches de mesure du temps.
Cours de chronomètre :
Utiliser la classe Chronomètre pour mesurer le temps est très simple. Comme les chronomètres dans la vie réelle, les objets de cette classe peuvent également démarrer, arrêter et remettre à zéro (réinitialiser) le compteur, mais il est beaucoup plus précis que les chronomètres ordinaires. Il peut être précis à la microseconde (c'est-à-dire des millions de secondes). . fraction de seconde).
Exemple de code :
Pour démontrer l'utilisation de Stopwatch, utilisons un morceau de code. Voici une application console qui cumule tous les entiers compris entre 1 et 1 million :
en utilisant System ;
espace de noms StopWatchClass
{
Programme de classe
{
static void Main(string[] arguments)
{
total long = 0 ;
pour (int i = 1 ; i <= 10000000 ; i++)
{
total += je;
}
}
}
}
Ajouter un objet Chronomètre :
La classe Stopwatch se trouve dans l’espace de noms System.Diagnostics. Voici le code après ajout de l'objet :
utiliser le système ;
en utilisant System.Diagnostics ;
espace de noms StopWatchClass ;
{
Programme de classe
{
static void Main(string[] arguments)
{
Chronomètre = new Chronomètre();
total long = 0 ;
pour (int i = 1 ; i <= 10000000 ; i++)
{
total += je;
}
}
}
}
Contrôlez l'objet Chronomètre :
Chronomètre fournit plusieurs méthodes pour contrôler l'objet Chronomètre. La méthode Start démarre une opération de synchronisation et la méthode Stop arrête la synchronisation. À ce stade, si la méthode Start est utilisée pour la deuxième fois, le chronométrage continuera et le résultat final du chronométrage est l’accumulation des deux chronométrages. Pour éviter cette situation, utilisez la méthode Reset pour remettre l'objet à zéro avant le deuxième minuteur. Aucune de ces trois méthodes ne nécessite de paramètres. Le code est :
utiliser le système ;
en utilisant System.Diagnostics ;
espace de noms StopWatchClass ;
{
Programme de classe
{
static void Main(string[] arguments)
{
Chronomètre = new Chronomètre();
total long = 0 ;
timer.Start();
pour (int i = 1; i <= 10000000; i++)
{
total += je;
}
timer.Stop();
}
}
}
Lire les résultats du chronomètre :
Après avoir terminé le timing, l'étape suivante consiste à lire les résultats du timing. La classe Stopwatch fournit les propriétés suivantes :
Elapsed : renvoie un objet TimeSpan, représentant l'intervalle de temps ;
ElapsedMilliseconds : renvoie le nombre de microsecondes écoulées par le timing. La précision est légèrement inférieure, adaptée à un timing légèrement plus long ;
ElapsedTicks : renvoie le nombre de ticks de minuterie écoulés. Un tick de minuterie est la plus petite unité de mesure possible pour un objet Chronomètre. La durée du tick de la minuterie est déterminée par l'ordinateur et le système d'exploitation spécifiques. La valeur du champ statique Fréquence de l’objet Chronomètre représente le nombre de ticks de minuterie contenus dans une seconde. Notez la différence dans les unités de temps utilisées par la propriété Ticks de TimeSpan.
L'une de ces propriétés doit être sélectionnée en fonction de la tâche de synchronisation. Dans notre exemple de programme, la propriété Elapsed fournit la précision requise pour afficher le nombre de microsecondes écoulées. C'est également la plus grande précision de TimeSpan.
Voici le code final du programme :
utiliser le système ;
en utilisant System.Diagnostics ;
espace de noms StopWatchClass ;
{
Programme de classe
{
static void Main(string[] arguments)
{
Chronomètre = new Chronomètre();
total long = 0 ;
timer.Start();
pour (int i = 1; i <= 10000000; i++)
{
total += je;
}
timer.Stop();
micro décimal = timer.Elapsed.Ticks / 10m;
Console.WriteLine("Le temps d'exécution était de {0:F1} microsecondes.", micro);
}
}
}
De plus, utilisez la propriété IsRunning pour vérifier si une instance de Stopwatch chronomètre et utilisez la méthode StartNew pour démarrer un nouveau minuteur.