Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês

Classe Stopwatch

 
System_CAPS_noteObservação

The .NET API Reference documentation has a new home. Visit the .NET API Browser on docs.microsoft.com to see the new experience.

Fornece um conjunto de métodos e propriedades que você pode usar para medir com precisão o tempo decorrido.

Para procurar o código-fonte do .NET Framework para este tipo, consulte o Reference Source.

Namespace:   System.Diagnostics
Assembly:  System (em System.dll)

System.Object
  System.Diagnostics.Stopwatch

public class Stopwatch

NomeDescrição
System_CAPS_pubmethodStopwatch()

Inicializa uma nova instância da classe Stopwatch.

NomeDescrição
System_CAPS_pubpropertyElapsed

Obtém o tempo total decorrido, medido pela instância atual.

System_CAPS_pubpropertyElapsedMilliseconds

Obtém o tempo total decorrido, medido pela instância atual, em milissegundos.

System_CAPS_pubpropertyElapsedTicks

Obtém o tempo total decorrido, medido pela instância atual, em tiques do temporizador.

System_CAPS_pubpropertyIsRunning

Obtém um valor que indica se o temporizador de Stopwatch está em execução.

NomeDescrição
System_CAPS_pubmethodEquals(Object)

Determina se o objeto especificado é igual ao objeto atual.(Herdado de Object.)

System_CAPS_protmethodFinalize()

Permite que um objeto tente liberar recursos e executar outras operações de limpeza antes de ser recuperado pela coleta de lixo.(Herdado de Object.)

System_CAPS_pubmethodGetHashCode()

Serve como a função de hash padrão.(Herdado de Object.)

System_CAPS_pubmethodSystem_CAPS_staticGetTimestamp()

Obtém o número de tiques atual no mecanismo de temporizador.

System_CAPS_pubmethodGetType()

Obtém o Type da instância atual.(Herdado de Object.)

System_CAPS_protmethodMemberwiseClone()

Cria uma cópia superficial do Object atual.(Herdado de Object.)

System_CAPS_pubmethodReset()

Interrompe a medida de intervalo de tempo e redefine o tempo decorrido para zero.

System_CAPS_pubmethodRestart()

Interrompe a medida de tempo de intervalo, redefine o tempo decorrido para zero e começa a medir o tempo decorrido.

System_CAPS_pubmethodStart()

Inicia ou retoma a medição do tempo decorrido de um intervalo.

System_CAPS_pubmethodSystem_CAPS_staticStartNew()

Inicializa uma nova instância Stopwatch, define a propriedade de tempo decorrido como zero e começa a medir o tempo decorrido.

System_CAPS_pubmethodStop()

Para a medição do tempo decorrido de um intervalo.

System_CAPS_pubmethodToString()

Retorna uma cadeia de caracteres que representa o objeto atual.(Herdado de Object.)

NomeDescrição
System_CAPS_pubfieldSystem_CAPS_staticFrequency

Obtém a frequência do temporizador como o número de tiques por segundo. Este campo é somente leitura.

System_CAPS_pubfieldSystem_CAPS_staticIsHighResolution

Indica se o timer é baseado em um contador de desempenho de alta resolução. Este campo é somente leitura.

System_CAPS_noteObservação

Para exibir o código-fonte do .NET Framework para este tipo, consulte o Reference Source. Percorra o código-fonte online, baixe a referência para exibição offline e percorrer as fontes (incluindo atualizações e patches) durante a depuração; consulte instructions.

Um Stopwatch instância pode medir o tempo decorrido para um intervalo ou o total de tempo decorrido em vários intervalos. Em um típico Stopwatch cenário, você chama o Start método, chame eventualmente o Stop método e, em seguida, verifique o tempo decorrido usando o Elapsed propriedade.

Um Stopwatch instância está em execução ou parado; use IsRunning para determinar o estado atual de um Stopwatch. Use Start para começar a medir o tempo decorrido; use Stop para interromper a medir o tempo decorrido. O valor de tempo decorrido através das propriedades de consulta Elapsed, ElapsedMilliseconds, ou ElapsedTicks. Você pode consultar as propriedades de tempo decorrido, enquanto a instância está em execução ou parado. Durante o tempo decorrido propriedades aumentarem continuamente o Stopwatch está em execução; eles permanecem constantes quando a instância é interrompida.

Por padrão, o valor de tempo decorrido de um Stopwatch instância é igual ao total de todos os intervalos de tempo medido. Cada chamada para Start começa a contar ao tempo decorrido cumulativo; cada chamada para Stop termina a medição de intervalo atual e congela o valor de tempo decorrido cumulativo. Use o Reset método para limpar o tempo decorrido cumulativo em existente Stopwatch instância.

O Stopwatch mede o tempo decorrido pela contagem de tiques de timer no mecanismo de temporizador subjacente. Se o hardware instalado e o sistema operacional de um contador de desempenho de alta resolução, oferecer suporte a Stopwatch classe usa esse contador para medir o tempo decorrido. Caso contrário, o Stopwatch classe usa o timer do sistema para medir o tempo decorrido. Use o Frequency e IsHighResolution campos para determinar a precisão e a resolução do Stopwatch implementação de tempo.

O Stopwatch classe auxilia a manipulação de contadores de desempenho relacionado à temporização do código gerenciado. Especificamente, o Frequency campo e GetTimestamp método pode ser usado no lugar das APIs do Win32 não gerenciado QueryPerformanceFrequency e QueryPerformanceCounter.

System_CAPS_noteObservação

Em um computador multiprocessador, não importa qual processador que o thread é executado no. No entanto, devido a erros no BIOS ou a camada de abstração de Hardware (HAL), você pode obter resultados diferentes em processadores diferentes. Para especificar a afinidade do processador para um segmento, use o ProcessThread.ProcessorAffinity método.

O exemplo a seguir demonstra como usar o Stopwatch classe para determinar o tempo de execução para um aplicativo.

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

O exemplo a seguir demonstra o uso da Stopwatch classe para calcular os dados de desempenho.

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

Plataforma Universal do Windows
Disponível desde 8
.NET Framework
Disponível desde 2.0
Biblioteca de Classes Portátil
Com suporte no: plataformas portáteis do .NET
Windows Phone Silverlight
Disponível desde 7.0
Windows Phone
Disponível desde 8.1

Quaisquer membros estáticos públicos ( Compartilhado no Visual Basic) desse tipo são thread-safe. Não há garantia de que qualquer membro de instância seja thread-safe.

Retornar ao início
Mostrar: