영어로 읽기

다음을 통해 공유


Stopwatch 클래스

정의

경과된 시간을 정확하게 측정하는 데 사용할 수 있는 메서드 및 속성 집합을 제공합니다.

C#
public class Stopwatch
상속
Stopwatch

예제

다음 예제에서는 Stopwatch 클래스를 사용하여 애플리케이션의 실행 시간을 확인하는 방법을 보여 줍니다.

C#
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 클래스를 사용하여 성능 데이터를 계산하는 방법을 보여 줍니다.

C#
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-10000.
                        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);
            }
        }
     }
}

설명

Stopwatch 인스턴스는 한 간격 동안 경과된 시간 또는 여러 간격에 걸쳐 경과된 총 시간을 측정할 수 있습니다. 일반적인 Stopwatch 시나리오에서는 Start 메서드를 호출한 다음 결국 Stop 메서드를 호출한 다음 Elapsed 속성을 사용하여 경과된 시간을 확인합니다.

Stopwatch 인스턴스가 실행 중이거나 중지되었습니다. IsRunning 사용하여 Stopwatch현재 상태를 확인합니다. Start 사용하여 경과된 시간 측정을 시작합니다. Stop 사용하여 경과된 시간 측정을 중지합니다. 속성 Elapsed, ElapsedMilliseconds또는 ElapsedTicks통해 경과된 시간 값을 쿼리합니다. 인스턴스가 실행 중이거나 중지되는 동안 경과된 시간 속성을 쿼리할 수 있습니다. Stopwatch 실행되는 동안 경과된 시간 속성이 꾸준히 증가합니다. 인스턴스가 중지될 때 상수로 유지됩니다.

기본적으로 Stopwatch 인스턴스의 경과된 시간 값은 측정된 모든 시간 간격의 합계와 같습니다. Start 대한 각 호출은 누적 경과 시간에 계산되기 시작합니다. Stop 대한 각 호출은 현재 간격 측정을 종료하고 누적 경과 시간 값을 고정합니다. 기존 Stopwatch 인스턴스에서 누적 경과 시간을 지우려면 Reset 메서드를 사용합니다.

Stopwatch 기본 타이머 메커니즘에서 타이머 틱을 계산하여 경과된 시간을 측정합니다. 설치된 하드웨어 및 운영 체제에서 고해상도 성능 카운터를 지원하는 경우 Stopwatch 클래스는 해당 카운터를 사용하여 경과된 시간을 측정합니다. 그렇지 않으면 Stopwatch 클래스는 시스템 타이머를 사용하여 경과된 시간을 측정합니다. FrequencyIsHighResolution 필드를 사용하여 Stopwatch 타이밍 구현의 정밀도 및 해상도를 결정합니다.

Stopwatch 클래스는 관리 코드 내에서 타이밍 관련 성능 카운터의 조작을 지원합니다. 특히 관리되지 않는 Windows API QueryPerformanceFrequencyQueryPerformanceCounter대신 Frequency 필드 및 GetTimestamp 메서드를 사용할 수 있습니다.

참고

다중 프로세서 컴퓨터에서는 스레드가 실행되는 프로세서는 중요하지 않습니다. 그러나 BIOS 또는 HAL(하드웨어 추상화 계층)의 버그로 인해 다른 프로세서에서 다른 타이밍 결과를 얻을 수 있습니다. 스레드에 대한 프로세서 선호도를 지정하려면 ProcessThread.ProcessorAffinity 메서드를 사용합니다.

생성자

Stopwatch()

Stopwatch 클래스의 새 인스턴스를 초기화합니다.

필드

Frequency

타이머의 빈도를 초당 틱 수로 가져옵니다. 이 필드는 읽기 전용입니다.

IsHighResolution

타이머가 고해상도 성능 카운터를 기반으로 하는지 여부를 나타냅니다. 이 필드는 읽기 전용입니다.

속성

Elapsed

현재 인스턴스에서 측정한 총 경과 시간을 가져옵니다.

ElapsedMilliseconds

현재 인스턴스에서 측정한 총 경과 시간(밀리초)을 가져옵니다.

ElapsedTicks

현재 인스턴스에서 측정한 총 경과 시간을 타이머 틱 단위로 가져옵니다.

IsRunning

Stopwatch 타이머가 실행 중인지 여부를 나타내는 값을 가져옵니다.

메서드

Equals(Object)

지정된 개체가 현재 개체와 같은지 여부를 확인합니다.

(다음에서 상속됨 Object)
GetElapsedTime(Int64, Int64)

GetTimestamp()사용하여 검색된 두 타임스탬프 사이의 경과된 시간을 가져옵니다.

GetElapsedTime(Int64)

GetTimestamp()사용하여 검색된 startingTimestamp 값 이후 경과된 시간을 가져옵니다.

GetHashCode()

기본 해시 함수로 사용됩니다.

(다음에서 상속됨 Object)
GetTimestamp()

타이머 메커니즘의 현재 틱 수를 가져옵니다.

GetType()

현재 인스턴스의 Type 가져옵니다.

(다음에서 상속됨 Object)
MemberwiseClone()

현재 Object단순 복사본을 만듭니다.

(다음에서 상속됨 Object)
Reset()

시간 간격 측정을 중지하고 경과된 시간을 0으로 다시 설정합니다.

Restart()

시간 간격 측정을 중지하고 경과된 시간을 0으로 다시 설정하며 경과된 시간 측정을 시작합니다.

Start()

간격에 대한 경과된 시간을 측정하여 시작하거나 다시 시작합니다.

StartNew()

Stopwatch 인스턴스를 초기화하고, 경과된 시간 속성을 0으로 설정하고, 경과된 시간 측정을 시작합니다.

Stop()

간격에 대한 경과 시간 측정을 중지합니다.

ToString()

Elapsed 시간을 문자열로 반환합니다.

ToString()

현재 개체를 나타내는 문자열을 반환합니다.

(다음에서 상속됨 Object)

적용 대상

제품 버전
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0

추가 정보