本文為機器翻譯文章。如需檢視英文版,請選取 [原文] 核取方塊。您也可以將滑鼠指標移到文字上,即可在快顯視窗顯示英文原文。
譯文
原文

Stopwatch 類別

 

提供一組方法和屬性,您可以使用這些方法和屬性,精確地測量已耗用時間。

若要瀏覽此類型的.NET Framework 原始程式碼,請參閱 Reference Source

命名空間:   System.Diagnostics
組件:  System (於 System.dll)

System.Object
  System.Diagnostics.Stopwatch

public class Stopwatch

名稱描述
System_CAPS_pubmethodStopwatch()

初始化 Stopwatch 類別的新執行個體。

名稱描述
System_CAPS_pubpropertyElapsed

取得目前執行個體所測量的已耗用時間總和。

System_CAPS_pubpropertyElapsedMilliseconds

取得目前執行個體所測量的已耗用時間總和,以毫秒為單位。

System_CAPS_pubpropertyElapsedTicks

取得目前執行個體所測量的已耗用時間總和,以計時器刻度為單位。

System_CAPS_pubpropertyIsRunning

取得值,指出 Stopwatch 計時器是否執行中。

名稱描述
System_CAPS_pubmethodEquals(Object)

判斷指定的物件是否等於目前的物件。(繼承自 Object。)

System_CAPS_protmethodFinalize()

在記憶體回收開始前,允許物件嘗試釋放資源,並執行其他清除作業。(繼承自 Object。)

System_CAPS_pubmethodGetHashCode()

做為預設雜湊函式。(繼承自 Object。)

System_CAPS_pubmethodSystem_CAPS_staticGetTimestamp()

取得計時器機制中的目前刻度數。

System_CAPS_pubmethodGetType()

取得目前執行個體的 Type(繼承自 Object。)

System_CAPS_protmethodMemberwiseClone()

建立目前 Object 的淺層複製。(繼承自 Object。)

System_CAPS_pubmethodReset()

停止時間間隔測量並將已耗用時間重設為零。

System_CAPS_pubmethodRestart()

停止時間間隔測量,並將耗用時間重設為零,然後開始測量耗用時間。

System_CAPS_pubmethodStart()

啟動或繼續測量間隔的已耗用時間。

System_CAPS_pubmethodSystem_CAPS_staticStartNew()

初始化新的 Stopwatch 執行個體,將已耗用時間屬性設定為零,然後開始測量已耗用時間。

System_CAPS_pubmethodStop()

停止測量間隔的已耗用時間。

System_CAPS_pubmethodToString()

傳回代表目前物件的字串。(繼承自 Object。)

名稱描述
System_CAPS_pubfieldSystem_CAPS_staticFrequency

取得計時器頻率,做為每秒的刻度數。 此欄位為唯讀。

System_CAPS_pubfieldSystem_CAPS_staticIsHighResolution

指示計時器是否以高解析度效能計數器為基礎。 此欄位為唯讀。

System_CAPS_note注意

若要檢視此類型的.NET Framework 原始程式碼,請參閱 Reference Source 您可以瀏覽原始碼、 下載的離線,參考並逐步執行 (包含修補程式和更新),在偵錯。see instructions.

A Stopwatch 執行個體可以跨多個間隔的一個間隔或已耗用時間總和中測量已耗用時間。 在一般 Stopwatch 案例中,呼叫 Start 方法,最後呼叫 Stop 方法,然後檢查 [經過時間使用 Elapsed 屬性。

A Stopwatch 執行個體正在執行或已停止; 使用 IsRunning 來判斷目前的狀態 Stopwatch 使用 Start 開始測量已耗用時間; 使用 Stop 停止測量已耗用時間。 查詢所經過時間值,透過內容 Elapsed, ,ElapsedMilliseconds, ,或 ElapsedTicks 執行或已停止執行個體時,您可以查詢已耗用時間屬性。 屬性是穩定上升的經過時間而 Stopwatch 會執行; 它們保持不變時停止執行個體。

根據預設,經過時間值的 Stopwatch 的執行個體等於所有測量的時間間隔的總計。 每次呼叫 Start 開始計算累積的經過時間; 在每次呼叫 Stop 結束目前的時間間隔測量並凍結累計的經過時間值。 使用 Reset 方法,以清除現有中累積的耗用時間 Stopwatch 執行個體。

Stopwatch 測量已耗用時間,來計算基礎計時器機制中的計時器刻度為單位。 如果已安裝的硬體和作業系統支援高解析度效能計數器,然後在 Stopwatch 類別會使用該計數器來測量已耗用時間。 否則, Stopwatch 類別會使用系統計時器測量已耗用時間。 使用 FrequencyIsHighResolution 欄位的有效位數和解決方法判斷 Stopwatch 計時實作。

Stopwatch 類別可協助 managed 程式碼中的時間相關的效能計數器的操作。 具體來說, Frequency 欄位和 GetTimestamp 方法可以用來取代未受管理的 Win32 Api QueryPerformanceFrequencyQueryPerformanceCounter

System_CAPS_note注意

在多處理器電腦上,並不重要的執行緒執行哪一個處理器。 不過,BIOS 或硬體抽象層 (HAL) 中的錯誤,因為您可以在不同的處理器上取得不同的計時結果。 若要指定執行緒的處理器相似性,使用 ProcessThread.ProcessorAffinity 方法。

下列範例示範如何使用 Stopwatch 類別,以判斷應用程式的執行時間。

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

下列範例示範如何使用 Stopwatch 類別計算的效能資料。

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

通用 Windows 平台
自 8 起供應
.NET Framework
自 2.0 起供應
可攜式類別庫
提供支援︰ 可攜式 .NET 平台
Windows Phone Silverlight
自 7.0 起供應
Windows Phone
自 8.1 起供應

此類型的任何 public static (在 Visual Basic 中 共用 在 Visual Basic 中) 成員皆為安全執行緒。不保證任何執行個體成員為安全執行緒。

回到頁首
顯示: