Stopwatch Clase
TOC
Collapse the table of content
Expand the table of content
Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Stopwatch (Clase)

 

Proporciona un conjunto de métodos y propiedades que puede usar para medir el tiempo transcurrido con precisión.

Para examinar el código fuente de .NET Framework para este tipo, vea la Reference Source.

Espacio de nombres:   System.Diagnostics
Ensamblado:  System (en System.dll)

System::Object
  System.Diagnostics::Stopwatch

public ref class Stopwatch 

NombreDescripción
System_CAPS_pubmethodStopwatch()

Inicializa una nueva instancia de la clase Stopwatch.

NombreDescripción
System_CAPS_pubpropertyElapsed

Obtiene el tiempo total transcurrido medido por la instancia actual.

System_CAPS_pubpropertyElapsedMilliseconds

Obtiene el tiempo total transcurrido medido por la instancia actual, en milisegundos.

System_CAPS_pubpropertyElapsedTicks

Obtiene el tiempo total transcurrido medido por la instancia actual, en tics de temporizador.

System_CAPS_pubpropertyIsRunning

Obtiene un valor que indica si el temporizador Stopwatch está en funcionamiento.

NombreDescripción
System_CAPS_pubmethodEquals(Object^)

Determina si el objeto especificado es igual al objeto actual.(Heredado de Object.)

System_CAPS_protmethodFinalize()

Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por el recolector de basura. (Heredado de Object.)

System_CAPS_pubmethodGetHashCode()

Sirve como la función hash predeterminada.(Heredado de Object.)

System_CAPS_pubmethodSystem_CAPS_staticGetTimestamp()

Obtiene el número actual de tics del mecanismo de temporización.

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object.)

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficial del Object actual.(Heredado de Object.)

System_CAPS_pubmethodReset()

Detiene la medición del intervalo de tiempo y restablece el tiempo transcurrido en cero.

System_CAPS_pubmethodRestart()

Detiene la medición del intervalo de tiempo, restablece el tiempo transcurrido en cero y comienza a medir el tiempo transcurrido.

System_CAPS_pubmethodStart()

Inicia o reanuda la medición del tiempo transcurrido para un intervalo.

System_CAPS_pubmethodSystem_CAPS_staticStartNew()

Inicializa una nueva instancia de Stopwatch, establece la propiedad de tiempo transcurrido en cero e inicia la medición de tiempo transcurrido.

System_CAPS_pubmethodStop()

Detiene la medición del tiempo transcurrido para un intervalo.

System_CAPS_pubmethodToString()

Retorna una cadena que representa al objeto actual. (Heredado de Object.)

NombreDescripción
System_CAPS_pubfieldSystem_CAPS_staticFrequency

Obtiene la frecuencia del temporizador en forma de número de tics por segundo. Este campo es de solo lectura.

System_CAPS_pubfieldSystem_CAPS_staticIsHighResolution

Indica si el temporizador se basa en un contador de rendimiento de alta resolución. Este campo es de solo lectura.

System_CAPS_noteNota

Para ver el código fuente de .NET Framework para este tipo, consulte el Reference Source. Puede examinar el código fuente en línea, descargue la referencia para verla sin conexión y recorrer (incluidas las revisiones y actualizaciones) durante la depuración; see instructions.

Un Stopwatch instancia puede medir el tiempo transcurrido para un intervalo o el total de tiempo transcurrido entre varios intervalos. En un típico Stopwatch escenario, se llama a la Start método, utilizamos finalmente el Stop método y, a continuación, compruebe el tiempo transcurrido mediante la Elapsed propiedad.

Un Stopwatch instancia está en ejecución o detenido; utilice IsRunning para determinar el estado actual de un Stopwatch. Utilice Start para empezar a medir el tiempo transcurrido; use Stop para detener la medición de tiempo transcurrido. Consultar el valor de tiempo transcurrido mediante las propiedades Elapsed, ElapsedMilliseconds, o ElapsedTicks. Puede consultar las propiedades de tiempo transcurrido mientras la instancia se está ejecutando o está detenido. El tiempo transcurrido aumentan continuamente propiedades mientras el Stopwatch está ejecutando; permanecen constantes cuando se detiene la instancia.

De forma predeterminada, el valor de tiempo transcurrido de una Stopwatch instancia es igual a la suma de todos los intervalos de tiempo medidos. Cada llamada a Start empieza el recuento en el tiempo transcurrido acumulado; cada llamada a Stop finaliza la medición del intervalo actual y se bloquea el valor de tiempo transcurrido acumulado. Utilice la Reset método para borrar el tiempo transcurrido acumulado en una existente Stopwatch instancia.

El Stopwatch mide el tiempo transcurrido contando pasos del temporizador en el mecanismo de temporización subyacente. Si el hardware instalado y el sistema operativo admiten un contador de rendimiento de alta resolución, la Stopwatch clase utiliza ese contador para medir el tiempo transcurrido. De lo contrario, la Stopwatch clase usa el temporizador del sistema para medir el tiempo transcurrido. Utilice la Frequency y IsHighResolution campos para determinar la precisión y la resolución de la Stopwatch implementación de control de tiempo.

La Stopwatch clase ayuda en la manipulación de los contadores de rendimiento relacionados con el control de tiempo dentro del código administrado. En concreto, el Frequency campo y GetTimestamp método puede utilizarse en lugar de la API de Win32 no administradas QueryPerformanceFrequency y QueryPerformanceCounter.

System_CAPS_noteNota

En un equipo con varios procesadores, no importa el procesador que el subproceso se ejecuta en. Sin embargo, debido a errores en el BIOS o la capa de abstracción de Hardware (HAL), puede obtener resultados de los diferentes intervalos en procesadores diferentes. Para especificar la afinidad del procesador para un subproceso, utilice el ProcessThread::ProcessorAffinity método.

En el ejemplo siguiente se muestra cómo utilizar el Stopwatch clase para determinar el tiempo de ejecución para una aplicación.

No hay ningún ejemplo de código disponible o este idioma no es compatible.

En el ejemplo siguiente se muestra el uso de la Stopwatch clase para calcular los datos de rendimiento.

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

Universal Windows Platform
Disponible desde 4.5
.NET Framework
Disponible desde 2.0
Portable Class Library
Compatible con: portable .NET platforms
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Volver al principio
Mostrar:
© 2016 Microsoft