Stopwatch.ElapsedMilliseconds Proprietà
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Ottiene il tempo totale trascorso misurato dall'istanza corrente in millisecondi.
public:
property long ElapsedMilliseconds { long get(); };public long ElapsedMilliseconds { get; }member this.ElapsedMilliseconds : int64Public ReadOnly Property ElapsedMilliseconds As LongValore della proprietà
Valore long Integer di sola lettura che rappresenta il numero totale di millisecondi misurato dall'istanza corrente.
Esempio
Nell'esempio seguente viene usata la Stopwatch classe per misurare le prestazioni di quattro implementazioni diverse per l'analisi di un numero intero da una stringa. Questo esempio di codice fa parte di un esempio più ampio fornito per la Stopwatch classe .
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 );
}
}
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);
}
}
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
Commenti
Questa proprietà rappresenta il tempo trascorso arrotondato per difetto all'intero valore di millisecondo più vicino. Per le misurazioni con precisione maggiore, usare le Elapsed proprietà o ElapsedTicks .
È possibile eseguire una query sulle proprietà Elapsed, ElapsedMillisecondse ElapsedTicks mentre l'istanza Stopwatch è in esecuzione o arrestata. Le proprietà del tempo trascorso aumentano costantemente mentre Stopwatch è in esecuzione e rimangono costanti quando l'istanza viene arrestata.
Per impostazione predefinita, il valore di tempo trascorso di un'istanza Stopwatch è uguale al totale di tutti gli intervalli di tempo misurati. Ogni chiamata a Start inizia il conteggio al tempo trascorso cumulativo. Ogni chiamata a Stop termina la misurazione dell'intervallo corrente e blocca il valore di tempo trascorso cumulativo. Usare il Reset metodo per cancellare il tempo trascorso cumulativo in un'istanza esistente Stopwatch .
Si applica a
Vedi anche
Collabora con noi su GitHub
L'origine di questo contenuto è disponibile in GitHub, in cui è anche possibile creare ed esaminare i problemi e le richieste pull. Per ulteriori informazioni, vedere la guida per i collaboratori.
