Stopwatch 클래스
정의
중요
일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.
경과 시간을 정확하게 측정하는 데 사용할 수 있는 일련의 메서드와 속성을 제공합니다.
public ref class Stopwatchpublic class Stopwatchtype Stopwatch = classPublic Class Stopwatch- 상속
-
Stopwatch
예제
다음 예제에서는 사용 하는 방법에 설명 합니다 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);
}
}
Imports System.Diagnostics
Imports System.Threading
Class Program
Shared Sub Main(ByVal args() As String)
Dim stopWatch As New Stopwatch()
stopWatch.Start()
Thread.Sleep(10000)
stopWatch.Stop()
' Get the elapsed time as a TimeSpan value.
Dim ts As TimeSpan = stopWatch.Elapsed
' Format and display the TimeSpan value.
Dim elapsedTime As String = String.Format("{0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10)
Console.WriteLine( "RunTime " + elapsedTime)
End Sub
End Class
다음 예제에서는 클래스를 사용하여 Stopwatch 성능 데이터를 계산하는 방법을 보여 줍니다.
#using <System.dll>
using namespace System;
using namespace System::Diagnostics;
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." );
}
Int64 frequency = Stopwatch::Frequency;
Console::WriteLine( " Timer frequency in ticks per second = {0}", frequency );
Int64 nanosecPerTick = (1000L * 1000L * 1000L) / frequency;
Console::WriteLine( " Timer is accurate within {0} nanoseconds", nanosecPerTick );
}
void TimeOperations()
{
Int64 nanosecPerTick = (1000L * 1000L * 1000L) / Stopwatch::Frequency;
const long numIterations = 10000;
// Define the operation title names.
array<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.
Int64 numTicks = 0;
Int64 numRollovers = 0;
Int64 maxTicks = 0;
Int64 minTicks = Int64::MaxValue;
int indexFastest = -1;
int indexSlowest = -1;
Int64 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++ )
{
Int64 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", 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", 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 );
}
}
int main()
{
DisplayTimerProperties();
Console::WriteLine();
Console::WriteLine( "Press the Enter key to begin:" );
Console::ReadLine();
Console::WriteLine();
TimeOperations();
}
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);
}
}
}
}
Imports System.Diagnostics
Class OperationsTimer
Public Shared Sub Main()
DisplayTimerProperties()
Console.WriteLine()
Console.WriteLine("Press the Enter key to begin:")
Console.ReadLine()
Console.WriteLine()
TimeOperations()
End Sub
Public Shared Sub DisplayTimerProperties()
' Display the timer frequency and resolution.
If Stopwatch.IsHighResolution Then
Console.WriteLine("Operations timed using the system's high-resolution performance counter.")
Else
Console.WriteLine("Operations timed using the DateTime class.")
End If
Dim frequency As Long = Stopwatch.Frequency
Console.WriteLine(" Timer frequency in ticks per second = {0}", frequency)
Dim nanosecPerTick As Long = 1000000000 / frequency
Console.WriteLine(" Timer is accurate within {0} nanoseconds", nanosecPerTick)
End Sub
Private Shared Sub TimeOperations()
Dim nanosecPerTick As Long = 1000000000 / Stopwatch.Frequency
Const numIterations As Long = 10000
' Define the operation title names.
Dim operationNames As String() = _
{"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.
Dim operation As Integer
For operation = 0 To 3
' Define variables for operation statistics.
Dim numTicks As Long = 0
Dim numRollovers As Long = 0
Dim maxTicks As Long = 0
Dim minTicks As Long = Int64.MaxValue
Dim indexFastest As Integer = - 1
Dim indexSlowest As Integer = - 1
Dim milliSec As Long = 0
Dim time10kOperations As Stopwatch = Stopwatch.StartNew()
' Run the current operation 10001 times.
' The first execution time will be tossed
' out, since it can skew the average time.
Dim i As Integer
For i = 0 To numIterations
Dim ticksThisTime As Long = 0
Dim inputNum As Integer
Dim timePerParse As Stopwatch
Select Case 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 e As FormatException
inputNum = 0
End Try
' Stop the timer, and save the
' elapsed ticks for the operation.
timePerParse.Stop()
ticksThisTime = timePerParse.ElapsedTicks
Case 1
' Parse a valid integer using
' the TryParse statement.
' Start a new stopwatch timer.
timePerParse = Stopwatch.StartNew()
If Not Int32.TryParse("0", inputNum) Then
inputNum = 0
End If
' Stop the timer, and save the
' elapsed ticks for the operation.
timePerParse.Stop()
ticksThisTime = timePerParse.ElapsedTicks
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 e As FormatException
inputNum = 0
End Try
' Stop the timer, and save the
' elapsed ticks for the operation.
timePerParse.Stop()
ticksThisTime = timePerParse.ElapsedTicks
Case 3
' Parse an invalid value using
' the TryParse statement.
' Start a new stopwatch timer.
timePerParse = Stopwatch.StartNew()
If Not Int32.TryParse("a", inputNum) Then
inputNum = 0
End If
' Stop the timer, and save the
' elapsed ticks for the operation.
timePerParse.Stop()
ticksThisTime = timePerParse.ElapsedTicks
Case Else
End Select
' Skip over the time for the first operation,
' just in case it caused a one-time
' performance hit.
If i = 0 Then
time10kOperations.Reset()
time10kOperations.Start()
Else
' Update operation statistics
' for iterations 1-10001.
If maxTicks < ticksThisTime Then
indexSlowest = i
maxTicks = ticksThisTime
End If
If minTicks > ticksThisTime Then
indexFastest = i
minTicks = ticksThisTime
End If
numTicks += ticksThisTime
If numTicks < ticksThisTime Then
' Keep track of rollovers.
numRollovers += 1
End If
End If
Next i
' 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)
Next operation
End Sub
End Class
설명
Stopwatch instance 한 간격 동안 경과된 시간 또는 여러 간격에 걸쳐 경과된 총 시간을 측정할 수 있습니다. 일반적인 Stopwatch 시나리오에서는 메서드를 Start 호출한 다음 결국 메서드를 Stop 호출한 다음 속성을 사용하여 Elapsed 경과된 시간을 검사.
Stopwatch instance 실행 중이거나 중지되었습니다. 를 사용하여 IsRunning 의 현재 상태를 확인합니다Stopwatch. 을 사용하여 Start 경과된 시간 측정을 시작합니다. 를 사용하여 Stop 경과된 시간 측정을 중지합니다. , ElapsedMilliseconds또는 ElapsedTicks속성 Elapsed을 통해 경과된 시간 값을 쿼리합니다. instance 실행 중이거나 중지된 동안 경과된 시간 속성을 쿼리할 수 있습니다. 경과된 시간 속성은 가 실행되는 동안 Stopwatch 꾸준히 증가합니다. instance 중지될 때 일정하게 유지됩니다.
기본적으로 instance 경과된 시간 값 Stopwatch 은 측정된 모든 시간 간격의 합계와 같습니다. 에 대한 Start 각 호출은 누적 경과 시간에 계산을 시작합니다. 에 대한 Stop 각 호출은 현재 간격 측정을 종료하고 누적 경과 시간 값을 고정합니다. 기존 instance Reset 누적 경과 시간을 지우려면 메서드를 Stopwatch 사용합니다.
기본 Stopwatch 타이머 메커니즘에서 타이머 틱을 계산하여 경과된 시간을 측정합니다. 설치된 하드웨어 및 운영 체제가 고해상도 성능 카운터를 지원하는 경우 클래스는 Stopwatch 해당 카운터를 사용하여 경과된 시간을 측정합니다. 그렇지 않으면 클래스는 Stopwatch 시스템 타이머를 사용하여 경과된 시간을 측정합니다. Frequency 및 IsHighResolution 필드를 사용하여 타이밍 구현의 정밀도 및 해상도를 Stopwatch 결정합니다.
클래스는 Stopwatch 관리 코드 내에서 타이밍 관련 성능 카운터의 조작을 지원합니다. 특히 필드 및 메서드는 Frequency 관리되지 않는 Windows API QueryPerformanceFrequency 및 QueryPerformanceCounter대신 사용할 수 GetTimestamp 있습니다.
참고
다중 프로세서 컴퓨터에서는 스레드가 실행되는 프로세서는 중요하지 않습니다. 그러나 BIOS 또는 HAL(하드웨어 추상화 계층)의 버그로 인해 다른 프로세서에서 다른 타이밍 결과를 얻을 수 있습니다. 스레드에 대한 프로세서 선호도를 지정하려면 메서드를 ProcessThread.ProcessorAffinity 사용합니다.
생성자
| Stopwatch() |
Stopwatch 클래스의 새 인스턴스를 초기화합니다. |
필드
| Frequency |
초당 틱 수로 나타낸 타이머의 빈도를 가져옵니다. 이 필드는 읽기 전용입니다. |
| IsHighResolution |
타이머가 고정밀도 성능 카운터를 기반으로 하는지 여부를 나타냅니다. 이 필드는 읽기 전용입니다. |
속성
| Elapsed |
현재 인스턴스가 측정한 총 경과 시간을 가져옵니다. |
| ElapsedMilliseconds |
현재 인스턴스가 측정한 밀리초 단위의 총 경과 시간을 가져옵니다. |
| ElapsedTicks |
현재 인스턴스가 측정한 총 경과 시간(타이머 틱 수)을 가져옵니다. |
| IsRunning |
Stopwatch 타이머가 실행 중인지를 나타내는 값을 가져옵니다. |
메서드
| Equals(Object) |
지정된 개체가 현재 개체와 같은지 확인합니다. (다음에서 상속됨 Object) |
| GetElapsedTime(Int64) |
를 사용하여 GetTimestamp()검색된 값 이후 경과 |
| GetElapsedTime(Int64, Int64) |
를 사용하여 GetTimestamp()검색된 두 타임스탬프 사이의 경과된 시간을 가져옵니다. |
| GetHashCode() |
기본 해시 함수로 작동합니다. (다음에서 상속됨 Object) |
| GetTimestamp() |
타이머 메커니즘에서 현재 틱 수를 가져옵니다. |
| GetType() |
현재 인스턴스의 Type을 가져옵니다. (다음에서 상속됨 Object) |
| MemberwiseClone() |
현재 Object의 단순 복사본을 만듭니다. (다음에서 상속됨 Object) |
| Reset() |
시간 간격 측정을 중지하고 경과 시간을 0으로 다시 설정합니다. |
| Restart() |
시간 간격 측정을 중지하고 경과 시간 값을 0으로 다시 설정한 다음 경과 시간 측정을 시작합니다. |
| Start() |
간격에 대한 경과 시간 측정을 시작하거나 다시 시작합니다. |
| StartNew() |
새 Stopwatch 인스턴스를 초기화하고 경과 시간 속성을 0으로 설정한 다음 경과 시간 측정을 시작합니다. |
| Stop() |
간격에 대한 경과 시간 측정을 중지합니다. |
| ToString() |
Elapsed 시간을 문자열로 반환합니다. |
| ToString() |
현재 개체를 나타내는 문자열을 반환합니다. (다음에서 상속됨 Object) |
적용 대상
추가 정보
GitHub에서 Microsoft와 공동 작업
이 콘텐츠의 원본은 GitHub에서 찾을 수 있으며, 여기서 문제와 끌어오기 요청을 만들고 검토할 수도 있습니다. 자세한 내용은 참여자 가이드를 참조하세요.
.NET
피드백
출시 예정: 2024년 내내 콘텐츠에 대한 피드백 메커니즘으로 GitHub 문제를 단계적으로 폐지하고 이를 새로운 피드백 시스템으로 바꿀 예정입니다. 자세한 내용은 다음을 참조하세요. https://aka.ms/ContentUserFeedback
다음에 대한 사용자 의견 제출 및 보기