Export (0) Print
Expand All

Stopwatch.ElapsedMilliseconds Property

Note: This property is new in the .NET Framework version 2.0.

Gets the total elapsed time measured by the current instance, in milliseconds.

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

'Declaration
Public ReadOnly Property ElapsedMilliseconds As Long
'Usage
Dim instance As Stopwatch
Dim value As Long

value = instance.ElapsedMilliseconds

/** @property */
public long get_ElapsedMilliseconds ()

public function get ElapsedMilliseconds () : long

Property Value

A read-only long integer representing the total number of milliseconds measured by the current instance.

This property represents elapsed time rounded down to the nearest whole millisecond value. For higher precision measurements, use the Elapsed or ElapsedTicks properties.

You can query the properties Elapsed, ElapsedMilliseconds, and ElapsedTicks while the Stopwatch instance is running or stopped. The elapsed time properties steadily increase while the Stopwatch is running; they remain constant when the instance is stopped.

By default, the elapsed time value of a Stopwatch instance equals the total of all measured time intervals. Each call to Start begins counting at the cumulative elapsed time; each call to Stop ends the current interval measurement and freezes the cumulative elapsed time value. Use the Reset method to clear the cumulative elapsed time in an existing Stopwatch instance.

The following example uses the Stopwatch class to measure the performance of four different implementations for parsing an integer from a string.

   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

private static void TimeOperations()
{
    long nanoSecPerTick = (1000L * 1000L * 1000L) / Stopwatch.Frequency;
    final 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 = 0;
            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 exp) {
                        inputNum = 0;
                    }
                    // Stop the timer, and save the
                    // elapsed ticks for the operation.
                    timePerParse.Stop();
                    ticksThisTime = timePerParse.get_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.get_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 exp) {
                        inputNum = 0;
                    }
                    // Stop the timer, and save the
                    // elapsed ticks for the operation.
                    timePerParse.Stop();
                    ticksThisTime = timePerParse.get_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.get_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.get_ElapsedMilliseconds();

        Console.WriteLine();
        Console.WriteLine("{0} Summary:", 
            operationNames.get_Item(operation));
        Console.WriteLine("  Slowest time:  #{0}/{1} = {2} ticks", 
            (Int32)indexSlowest, (Int64)numIterations, (Int64)maxTicks);
        Console.WriteLine("  Fastest time:  #{0}/{1} = {2} ticks", 
            (Int32)indexFastest, (Int64)numIterations, (Int64)minTicks);
        Console.WriteLine("  Average time:  {0} ticks = {1} nanoseconds", 
            (System.Double)(numTicks / numIterations), 
            (System.Double)(numTicks * nanoSecPerTick / numIterations));
        Console.WriteLine("  Total time looping through {0} operations: "
            + "{1} milliseconds", (Int64)numIterations, (Int64)milliSec);
    }
} //TimeOperations 

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see System Requirements.

.NET Framework

Supported in: 2.0

Community Additions

ADD
Show:
© 2014 Microsoft