Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Stopwatch classe

 

Date de publication : novembre 2016

Fournit un jeu de méthodes et de propriétés que vous pouvez utiliser pour mesurer le temps écoulé précisément.

Pour parcourir le code source .NET Framework pour ce type, consultez la Reference Source.

Espace de noms:   System.Diagnostics
Assembly:  System (dans System.dll)

System.Object
  System.Diagnostics.Stopwatch

public class Stopwatch

NomDescription
System_CAPS_pubmethodStopwatch()

Initialise une nouvelle instance de la classe Stopwatch.

NomDescription
System_CAPS_pubpropertyElapsed

Obtient le temps total écoulé mesuré par l'instance actuelle.

System_CAPS_pubpropertyElapsedMilliseconds

Obtient le temps total écoulé mesuré par l'instance actuelle, en millisecondes.

System_CAPS_pubpropertyElapsedTicks

Obtient le temps total écoulé mesuré par l'instance actuelle, en graduations de minuterie.

System_CAPS_pubpropertyIsRunning

Obtient une valeur indiquant si le minuteur Stopwatch est en cours d’exécution.

NomDescription
System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_protmethodFinalize()

Autorise un objet à tenter de libérer des ressources et à exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par une opération garbage collection.(Hérité de Object.)

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut.(Hérité de Object.)

System_CAPS_pubmethodSystem_CAPS_staticGetTimestamp()

Obtient le nombre actuel de graduations dans le mécanisme de minuterie.

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_protmethodMemberwiseClone()

Crée une copie superficielle du Object actuel.(Hérité de Object.)

System_CAPS_pubmethodReset()

Arrête la mesure d’intervalle de temps et remet la durée calendaire à zéro.

System_CAPS_pubmethodRestart()

Arrête la mesure d’intervalle de temps, réinitialise la durée calendaire sur zéro puis commence à la mesurer.

System_CAPS_pubmethodStart()

Démarre ou reprend la mesure de la durée calendaire pour un intervalle.

System_CAPS_pubmethodSystem_CAPS_staticStartNew()

Initialise une nouvelle instance de Stopwatch, définit la propriété de temps écoulé sur zéro et commence à mesurer le temps écoulé.

System_CAPS_pubmethodStop()

Cesse de mesurer la durée calendaire pour un intervalle.

System_CAPS_pubmethodToString()

Retourne une chaîne qui représente l'objet actuel.(Hérité de Object.)

NomDescription
System_CAPS_pubfieldSystem_CAPS_staticFrequency

Obtient la fréquence de la minuterie en nombre de graduations par seconde. Ce champ est en lecture seule.

System_CAPS_pubfieldSystem_CAPS_staticIsHighResolution

Indique si la minuterie est basée sur un compteur de performance haute résolution. Ce champ est en lecture seule.

System_CAPS_noteRemarque

Pour afficher le code source .NET Framework pour ce type, consultez la Reference Source. Vous pouvez parcourir le code source en ligne, télécharger la référence hors connexion et parcourir les sources (y compris les correctifs et mises à jour) pendant le débogage ; see instructions.

Un Stopwatch instance peut mesurer le temps écoulé pour un intervalle ou le total du temps écoulé sur plusieurs intervalles. Dans un type Stopwatch scénario, vous appelez le Start (méthode), puis le Stop (méthode), puis vous vérifiez le temps écoulé à l’aide la Elapsed propriété.

Un Stopwatch instance est en cours d’exécution ou arrêté, utilisez IsRunning pour déterminer l’état actuel d’un Stopwatch. Utilisez Start pour commencer à mesurer le temps écoulé ; utiliser Stop pour arrêter de mesurer le temps écoulé. Interroger la valeur de temps écoulé via les propriétés Elapsed, ElapsedMilliseconds, ou ElapsedTicks. Vous pouvez interroger les propriétés de temps écoulé pendant que l’instance est en cours d’exécution ou arrêté. Alors que le temps écoulé augmentent régulièrement des propriétés de la Stopwatch est en cours d’exécution ; ils restent constants lorsque l’instance est arrêtée.

Par défaut, la valeur de temps écoulé d’un Stopwatch instance équivaut au total de tous les intervalles de temps mesurés. Chaque appel à Start commence à compter au temps total passé ; chaque appel à Stop termine la mesure d’intervalle en cours et gèle la valeur du temps écoulé. Utilisez la Reset méthode pour effacer le temps total passé dans un Stopwatch instance.

Le Stopwatch mesure le temps écoulé en comptant les graduations de la minuterie dans le mécanisme de minuterie sous-jacent. Si le matériel installé et le système d’exploitation prend en charge un compteur de performance haute résolution, la Stopwatch classe utilise ce compteur pour mesurer le temps écoulé. Dans le cas contraire, la Stopwatch classe utilise l’horloge système pour mesurer le temps écoulé. Utilisez le Frequency et IsHighResolution champs afin de déterminer la précision et la résolution de le Stopwatch implémentation du minutage.

La Stopwatch classe facilite la manipulation des compteurs de performance de synchronisation dans le code managé. Plus précisément, le Frequency champ et GetTimestamp méthode peut être utilisée à la place de l’API Win32 non gérées QueryPerformanceFrequency et QueryPerformanceCounter.

System_CAPS_noteRemarque

Sur un ordinateur multiprocesseur, peu importe le processeur sur lequel le thread s’exécute. Toutefois, en raison des bogues dans le BIOS ou la couche d’Abstraction matérielle (HAL), vous pouvez obtenir des résultats de minutage différents sur différents processeurs. Pour spécifier l’affinité du processeur pour un thread, utilisez la ProcessThread.ProcessorAffinity méthode.

L’exemple suivant montre comment utiliser la Stopwatch classe afin de déterminer la durée d’exécution d’une application.

using System;
using System.Diagnostics;
using System.Threading;
class Program
{
    static void Main(string[] args)
    {
        Stopwatch stopWatch = new Stopwatch();
        stopWatch.Start();
        Thread.Sleep(10000);
        stopWatch.Stop();
        // Get the elapsed time as a TimeSpan value.
        TimeSpan ts = stopWatch.Elapsed;

        // Format and display the TimeSpan value.
        string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
            ts.Hours, ts.Minutes, ts.Seconds,
            ts.Milliseconds / 10);
        Console.WriteLine("RunTime " + elapsedTime);
    }
}

L’exemple suivant illustre l’utilisation de la Stopwatch classe pour calculer des données de performances.

using System;
using System.Diagnostics;

namespace StopWatchSample
{
    class OperationsTimer
    {
        public static void Main()
        {
            DisplayTimerProperties();

            Console.WriteLine();
            Console.WriteLine("Press the Enter key to begin:");
            Console.ReadLine();
            Console.WriteLine();

            TimeOperations();
        }

        public static void DisplayTimerProperties()
        {
            // Display the timer frequency and resolution.
            if (Stopwatch.IsHighResolution)
            {
                Console.WriteLine("Operations timed using the system's high-resolution performance counter.");
            }
            else 
            {
                Console.WriteLine("Operations timed using the DateTime class.");
            }

            long frequency = Stopwatch.Frequency;
            Console.WriteLine("  Timer frequency in ticks per second = {0}",
                frequency);
            long nanosecPerTick = (1000L*1000L*1000L) / frequency;
            Console.WriteLine("  Timer is accurate within {0} nanoseconds", 
                nanosecPerTick);
        }

        private static void TimeOperations()
        {
            long nanosecPerTick = (1000L*1000L*1000L) / Stopwatch.Frequency;
            const long numIterations = 10000;

            // Define the operation title names.
            String [] operationNames = {"Operation: Int32.Parse(\"0\")",
                                           "Operation: Int32.TryParse(\"0\")",
                                           "Operation: Int32.Parse(\"a\")",
                                           "Operation: Int32.TryParse(\"a\")"};


            // Time four different implementations for parsing 
            // an integer from a string. 

            for (int operation = 0; operation <= 3; operation++)
            {
                // Define variables for operation statistics.
                long numTicks = 0;
                long numRollovers = 0;
                long maxTicks = 0;
                long minTicks = Int64.MaxValue;
                int indexFastest = -1;
                int indexSlowest = -1;
                long milliSec = 0;

                Stopwatch time10kOperations = Stopwatch.StartNew();

                // Run the current operation 10001 times.
                // The first execution time will be tossed
                // out, since it can skew the average time.

                for (int i=0; i<=numIterations; i++) 
                {
                    long ticksThisTime = 0;
                    int inputNum;
                    Stopwatch timePerParse;

                    switch (operation)
                    {
                        case 0:
                            // Parse a valid integer using
                            // a try-catch statement.

                            // Start a new stopwatch timer.
                            timePerParse = Stopwatch.StartNew();

                            try 
                            {
                                inputNum = Int32.Parse("0");
                            }
                            catch (FormatException)
                            {
                                inputNum = 0;
                            }

                            // Stop the timer, and save the
                            // elapsed ticks for the operation.

                            timePerParse.Stop();
                            ticksThisTime = timePerParse.ElapsedTicks;
                            break;
                        case 1:
                            // Parse a valid integer using
                            // the TryParse statement.

                            // Start a new stopwatch timer.
                            timePerParse = Stopwatch.StartNew();

                            if (!Int32.TryParse("0", out inputNum))
                            { 
                                inputNum = 0;
                            }

                            // Stop the timer, and save the
                            // elapsed ticks for the operation.
                            timePerParse.Stop();
                            ticksThisTime = timePerParse.ElapsedTicks;
                            break;
                        case 2:
                            // Parse an invalid value using
                            // a try-catch statement.

                            // Start a new stopwatch timer.
                            timePerParse = Stopwatch.StartNew();

                            try 
                            {
                                inputNum = Int32.Parse("a");
                            }
                            catch (FormatException)
                            {
                                inputNum = 0;
                            }

                            // Stop the timer, and save the
                            // elapsed ticks for the operation.
                            timePerParse.Stop();
                            ticksThisTime = timePerParse.ElapsedTicks;
                            break;
                        case 3:
                            // Parse an invalid value using
                            // the TryParse statement.

                            // Start a new stopwatch timer.
                            timePerParse = Stopwatch.StartNew();

                            if (!Int32.TryParse("a", out inputNum))
                            { 
                                inputNum = 0;
                            }

                            // Stop the timer, and save the
                            // elapsed ticks for the operation.
                            timePerParse.Stop();
                            ticksThisTime = timePerParse.ElapsedTicks;
                            break;

                        default:
                            break;
                    }

                    // Skip over the time for the first operation,
                    // just in case it caused a one-time
                    // performance hit.
                    if (i == 0)
                    {
                        time10kOperations.Reset();
                        time10kOperations.Start();
                    }
                    else 
                    {

                        // Update operation statistics
                        // for iterations 1-10001.
                        if (maxTicks < ticksThisTime)
                        {
                            indexSlowest = i;
                            maxTicks = ticksThisTime;
                        }
                        if (minTicks > ticksThisTime)
                        {
                            indexFastest = i;
                            minTicks = ticksThisTime;
                        }
                        numTicks += ticksThisTime;
                        if (numTicks < ticksThisTime)
                        {
                            // Keep track of rollovers.
                            numRollovers ++;
                        }
                    }
                }  

                // Display the statistics for 10000 iterations.

                time10kOperations.Stop();
                milliSec = time10kOperations.ElapsedMilliseconds;

                Console.WriteLine();
                Console.WriteLine("{0} Summary:", operationNames[operation]);
                Console.WriteLine("  Slowest time:  #{0}/{1} = {2} ticks",
                    indexSlowest, numIterations, maxTicks);
                Console.WriteLine("  Fastest time:  #{0}/{1} = {2} ticks",
                    indexFastest, numIterations, minTicks);
                Console.WriteLine("  Average time:  {0} ticks = {1} nanoseconds", 
                    numTicks / numIterations, 
                    (numTicks * nanosecPerTick) / numIterations );
                Console.WriteLine("  Total time looping through {0} operations: {1} milliseconds", 
                    numIterations, milliSec);
            }
        }
     }
}

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 2.0
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight pour Windows Phone
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1

Tous les membres statiques publics ( Shared en Visual Basic) de ce type sont thread-safe. Les membres d’instance n’ont pas la garantie d’être thread-safe.

Retour au début
Afficher: