timewatcher - tiempo en c#

Mida el tiempo de ejecución en C#

Question

Quiero medir la ejecución de un fragmento de código y me pregunto cuál es el mejor método para hacerlo.

Opción 1:

DateTime StartTime = DateTime.Now;

//Code

TimeSpan ts = DateTime.Now.Subtract(StartTime);
string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
        ts.Hours, ts.Minutes, ts.Seconds,
        ts.Milliseconds / 10);
Console.WriteLine(elapsedTime, "RunTime");

Opción 2: usar System.Diagnostics;

    Stopwatch stopWatch = new Stopwatch();
    stopWatch.Start();

    //Code

    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(elapsedTime, "RunTime");

Esto no es solo para la evaluación comparativa, es realmente parte de la aplicación. El tiempo que tarda la función en ejecutarse es información relevante. Sin embargo, no es necesario que sea atómico o hiper-preciso.

¿Qué opción es mejor para el código de producción, o alguien más usa algo diferente y quizás mejor?

Answer 1

Es probable que ambos se ajusten a tus necesidades, pero yo diría que utilices StopWatch . ¿Por qué? Porque es para la tarea que estás haciendo.

Tienes una clase creada para devolver la fecha / hora actual, que puede usarse para cronometrar las cosas, y tienes una clase específicamente diseñada para cronometrar las cosas.

En este caso, las diferencias solo existen realmente si necesita una precisión de milisegundos (en este caso, el StopWatch es más preciso), pero como principal general si existe una herramienta específica para la tarea que está buscando, entonces es la mejor para usar.

Answer 2

Generalmente uso StopWatch para este tipo de situación.

Desde la página MSDN :

Cronógrafo

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

En la siguiente publicación lo uso para comparar el tiempo de ejecución de LINQ vs PLINQ:

Paralelo LINQ (PLINQ) con Visual Studio 2010

Answer 3

La clase Stopwatch está diseñada específicamente para medir el tiempo transcurrido y puede (si está disponible en su hardware) proporcionar buena granularidad / precisión utilizando un temporizador de hardware de alta frecuencia subyacente. Así que esta parece ser la mejor opción.

La propiedad IsHighResolution se puede usar para determinar si la sincronización de alta resolución está disponible. Según la documentación, esta clase ofrece un contenedor de las API de Win32 ''mejor disponibles'' para un tiempo preciso:

Específicamente, el campo Frequency y el método GetTimestamp se pueden usar en lugar de las API Win32 no administradas QueryPerformanceFrequency y QueryPerformanceCounter .

Hay antecedentes detallados sobre esas API de Win32 [aquí] y en documentos de MSDN vinculados 2 .

Temporizador de alta resolución

Un contador es un término general utilizado en la programación para referirse a una variable en incremento. Algunos sistemas incluyen un contador de rendimiento de alta resolución que proporciona tiempos transcurridos de alta resolución.

Si existe un contador de rendimiento de alta resolución en el sistema, puede usar la función QueryPerformanceFrequency para expresar la frecuencia, en conteos por segundo. El valor del conteo depende del procesador. En algunos procesadores, por ejemplo, el recuento puede ser la velocidad de ciclo del reloj del procesador.

La función QueryPerformanceCounter recupera el valor actual del contador de rendimiento de alta resolución. Al llamar a esta función al principio y al final de una sección de código, una aplicación utiliza esencialmente el contador como un temporizador de alta resolución. Por ejemplo, supongamos que QueryPerformanceFrequency indica que la frecuencia del contador de rendimiento de alta resolución es 50,000 cuentas por segundo. Si la aplicación llama a QueryPerformanceCounter inmediatamente antes e inmediatamente después de la sección del código que se va a cronometrar, los valores del contador pueden ser de 1500 cuentas y 3500 cuentas, respectivamente. Estos valores indicarían que transcurrieron .04 segundos (2000 conteos) mientras se ejecutó el código.

Answer 4

No es solo que StopWatch sea ​​más preciso, sino que DateTime.Now dará resultados incorrectos en algunas circunstancias.

Considere lo que sucede durante un cambio de horario de verano, por ejemplo, usando DateTime.Now puede dar una respuesta negativa !

Answer 5

Tampoco dañará el rendimiento, porque dices que no es tan crítico. StopWatch parece más apropiado: solo resta tiempo del tiempo y no una fecha de otro. La información de fecha requiere un poco más de memoria y tiempo de CPU para tratar. También hay formas de hacer que el código sea más limpio, en caso de que planee reutilizarlo en varios lugares. La sobrecarga using viene a la mente. Buscaré un ejemplo. Ok, código robado de:

http://stevesmithblog.com/blog/great-uses-of-using-statement-in-c/

public class ConsoleAutoStopWatch : IDisposable
{
    private readonly Stopwatch _stopWatch;

    public ConsoleAutoStopWatch()
    {
        _stopWatch = new Stopwatch();
        _stopWatch.Start();
    }

    public void Dispose()
    {
        _stopWatch.Stop();
        TimeSpan ts = _stopWatch.Elapsed;

        string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
                                           ts.Hours, ts.Minutes, ts.Seconds,
                                           ts.Milliseconds / 10);
        Console.WriteLine(elapsedTime, "RunTime");
    }
}

private static void UsingStopWatchUsage()
{
    Console.WriteLine("ConsoleAutoStopWatch Used: ");
    using (new ConsoleAutoStopWatch())
    {
        Thread.Sleep(3000);
    }
}

Answer 6

Tengo una pequeña clase para hacer este tipo de cosas ad hoc. Utiliza la clase de cronómetro - prueba de micro rendimiento de c # .

p.ej.

var tester = new PerformanceTester(() => SomeMethod());
tester.MeasureExecTime(1000);
Console.Writeline(string.Format("Executed in {0} milliseconds", tester.AverageTime.TotalMilliseconds));

Answer 7

Tomé la respuesta de Hamish simplificándolo y lo hice un poco más general en caso de que necesite iniciar sesión en otro lugar:

public class AutoStopWatch : Stopwatch, IDisposable {

    public AutoStopWatch() {
        Start();
    }

    public virtual void Dispose() {
        Stop();
    }
}

 public class AutoStopWatchConsole : AutoStopWatch {

    private readonly string prefix;

    public AutoStopWatchConsole(string prefix = "") {
        this.prefix = prefix;
    }

    public override void Dispose() {
        base.Dispose();

        string format = Elapsed.Days > 0 ? "{0} days " : "";
        format += "{1:00}:{2:00}:{3:00}.{4:00}";

        Console.WriteLine(prefix + " " + format.Format(Elapsed.Days, Elapsed.Hours, Elapsed.Minutes, Elapsed.Seconds, Elapsed.Milliseconds / 10));
    }
}

private static void Usage() {

    Console.WriteLine("AutoStopWatch Used: ");
    using (var sw = new AutoStopWatch()) {
        Thread.Sleep(3000);

        Console.WriteLine(sw.Elapsed.ToString("h''h ''m''m ''s''s''"));
    }

    Console.WriteLine("AutoStopWatchConsole Used: ");
    using (var sw = new AutoStopWatchConsole()) {
        Thread.Sleep(3000);
    }

}

Answer 8

Use el código a continuación

DateTime dExecutionTime;
dExecutionTime = DateTime.Now;
      TimeSpan span = DateTime.Now.Subtract(dExecutionTime);
                  lblExecutinTime.Text = "total time taken " +   Math.Round(span.TotalMinutes,2) + " minutes .   >>---> " + DateTime.Now.ToShortTimeString();