Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Stopwatch-Klasse

 

Veröffentlicht: Oktober 2016

Stellt eine Gruppe von Methoden und Eigenschaften bereit, mit denen die verstrichene Zeit exakt gemessen werden kann.

Um den .NET Framework-Quellcode für diesen Typ zu durchsuchen, finden Sie unter der Reference Source.

Namespace:   System.Diagnostics
Assembly:  System (in System.dll)

System.Object
  System.Diagnostics.Stopwatch

public class Stopwatch

NameBeschreibung
System_CAPS_pubmethodStopwatch()

Initialisiert eine neue Instanz der Stopwatch-Klasse.

NameBeschreibung
System_CAPS_pubpropertyElapsed

Ruft die gesamte verstrichene Zeit ab, die von der aktuellen Instanz gemessen wurde.

System_CAPS_pubpropertyElapsedMilliseconds

Ruft die gesamte verstrichene Zeit in Millisekunden ab, die von der aktuellen Instanz gemessen wurde.

System_CAPS_pubpropertyElapsedTicks

Ruft die gesamte verstrichene Zeit, die von der aktuellen Instanz gemessen wurde, in Zeitgeberintervallen (Ticks) ab.

System_CAPS_pubpropertyIsRunning

Ruft einen Wert ab, der angibt, ob der Stopwatch-Zeitgeber ausgeführt wird.

NameBeschreibung
System_CAPS_pubmethodEquals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.(Geerbt von „Object“.)

System_CAPS_protmethodFinalize()

Gibt einem Objekt Gelegenheit zu dem Versuch, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird.(Geerbt von „Object“.)

System_CAPS_pubmethodGetHashCode()

Fungiert als die Standardhashfunktion.(Geerbt von „Object“.)

System_CAPS_pubmethodSystem_CAPS_staticGetTimestamp()

Ruft die aktuelle Anzahl der Ticks im Zeitgebermechanismus ab.

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_protmethodMemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.(Geerbt von „Object“.)

System_CAPS_pubmethodReset()

Beendet die Zeitintervallmessung und setzt die verstrichene Zeit auf 0 (null) zurück.

System_CAPS_pubmethodRestart()

Beendet die Zeitintervallmessung, setzt die verstrichene Zeit auf 0 (null) zurück, und startet die Messung der verstrichenen Zeit.

System_CAPS_pubmethodStart()

Startet den Messvorgang der verstrichenen Zeit für ein Intervall oder nimmt diesen wieder auf.

System_CAPS_pubmethodSystem_CAPS_staticStartNew()

Initialisiert eine neue Stopwatch-Instanz, legt die Eigenschaft der verstrichenen Zeit auf 0 (null) fest und beginnt mit dem Messen der verstrichenen Zeit.

System_CAPS_pubmethodStop()

Beendet das Messen der verstrichenen Zeit für ein Intervall.

System_CAPS_pubmethodToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.(Geerbt von „Object“.)

NameBeschreibung
System_CAPS_pubfieldSystem_CAPS_staticFrequency

Ruft die Frequenz des Zeitgebers als Anzahl der Ticks pro Sekunde ab. Dieses Feld ist schreibgeschützt.

System_CAPS_pubfieldSystem_CAPS_staticIsHighResolution

Gibt an, ob der Zeitgeber auf einem hochauflösenden Leistungsindikator basiert. Dieses Feld ist schreibgeschützt.

System_CAPS_noteHinweis

Die .NET Framework-Quellcodes für diesen Typ finden Sie unter der Reference Source. Sie können den Quellcode online Durchsuchen, Referenz für die Offlineanzeige herunterladen und schrittweise durchlaufen (inklusive Patches und Updates) während des Debuggens; see instructions.

Ein Stopwatch -Instanz kann die verstrichene Zeit für ein Intervall oder die insgesamt verstrichene Zeit für mehrere Intervalle gemessen. In einer normalen Stopwatch Szenario rufen Sie die Start -Methode schließlich rufen Sie dann die Stop -Methode, und dann überprüfen, verstrichene Zeit verwendet die Elapsed Eigenschaft.

Ein Stopwatch -Instanz wird entweder ausgeführt oder beendet; verwenden Sie IsRunning bestimmt den aktuellen Zustand des eine Stopwatch. Verwenden Sie Start zum Messen der verstrichenen Zeit; beginnen verwenden Stop beenden Sie den Messvorgang der verstrichenen Zeit. Fragen Sie den Wert der verstrichenen Zeit über die Eigenschaften Elapsed, ElapsedMilliseconds, oder ElapsedTicks. Sie können die Eigenschaften der verstrichenen Zeit Abfragen, während die Instanz ausgeführt oder beendet wird. While-Eigenschaften einen stetigen Anstieg verstrichener Zeit der Stopwatch wird ausgeführt; sie konstant bleiben, wenn die Instanz beendet ist.

Standardmäßig den Wert der verstrichenen Zeit, der eine Stopwatch Instanz entspricht der Summe der alle gemessenen Zeitintervalle. Jeder Aufruf von Start zählen die kumulierte verstrichene Zeit, beginnt jeder Aufruf von Stop Messung des aktuellen Intervalls beendet und der kumulierte verstrichene Zeitwert eingefroren. Verwenden der Reset Methode, um die kumulierte verstrichene Zeit in einer vorhandenen löschen Stopwatch Instanz.

Die Stopwatch misst verstrichene Zeit, indem Ticks des Zeitgebers im zugrunde liegenden Zeitgebermechanismus zählt. Wenn die installierte Hardware und das Betriebssystem einen hochauflösenden Leistungsindikator unterstützen die Stopwatch Klasse zum Messen der verstrichenen Zeit verwendet. Andernfalls die Stopwatch Klasse verwendet den Systemzeitgeber, um die verstrichene Zeit zu messen. Verwenden der Frequency und IsHighResolution Felder bestimmen die Genauigkeit und die Lösung von der Stopwatch Timing-Implementierung.

Die Stopwatch -Klasse unterstützt das Ändern der zeitbezogenen Leistungsindikatoren innerhalb von verwaltetem Code. Insbesondere das Frequency Feld und GetTimestamp -Methode anstelle der nicht verwalteten Win32-APIs verwendet werden QueryPerformanceFrequency und QueryPerformanceCounter.

System_CAPS_noteHinweis

Auf Multiprozessorcomputern spielt es keine Rolle, welcher Prozessor auf der Thread ausgeführt. Aufgrund von Fehlern im BIOS oder (Hardware Abstraction Layer, HAL), können Sie jedoch unterschiedliche Ergebnisse auf unterschiedlichen Prozessoren abrufen. Um die Prozessoraffinität für einen Thread anzugeben, verwenden Sie die ProcessThread.ProcessorAffinity Methode.

Im folgenden Beispiel wird veranschaulicht, wie die Stopwatch Klasse, um die Ausführungszeit für eine Anwendung zu bestimmen.

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);
    }
}

Das folgende Beispiel veranschaulicht die Verwendung von der Stopwatch -Klasse zum Berechnen von Leistungsdaten.

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);
            }
        }
     }
}

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 2.0
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1

Alle öffentlichen statischen Member ( Shared in Visual Basic) dieses Typs sind threadsicher. Die Threadsicherheit für Instanzmember ist nicht garantiert.

Zurück zum Anfang
Anzeigen: