¿Envolviendo el cronometraje StopWatch con un delegado o lambda?

Estoy escribiendo un código como este, haciendo un poco de tiempo rápido y sucio:

var sw = new Stopwatch();
sw.Start();
for (int i = 0; i < 1000; i++)
{
    b = DoStuff(s);
}
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);

Seguramente hay una manera de llamar a este fragmento de código de tiempo como una lambda .NET 3.0 elegante en lugar de (Dios no lo quiera) cortarlo y pegarlo varias veces y reemplazarlo DoStuff(s)con DoSomethingElse(s)?

Sé que se puede hacer como un Delegatemétodo, pero me pregunto sobre el método lambda.

¿Qué tal ampliar la clase de cronómetro?

public static class StopwatchExtensions
{
    public static long Time(this Stopwatch sw, Action action, int iterations)
    {
        sw.Reset();
        sw.Start(); 
        for (int i = 0; i < iterations; i++)
        {
            action();
        }
        sw.Stop();

        return sw.ElapsedMilliseconds;
    }
}

Entonces llámalo así:

var s = new Stopwatch();
Console.WriteLine(s.Time(() => DoStuff(), 1000));

Podría agregar otra sobrecarga que omita el parámetro "iteraciones" y llame a esta versión con algún valor predeterminado (como 1000).

Esto es lo que he estado usando:

public class DisposableStopwatch: IDisposable {
    private readonly Stopwatch sw;
    private readonly Action<TimeSpan> f;

    public DisposableStopwatch(Action<TimeSpan> f) {
        this.f = f;
        sw = Stopwatch.StartNew();
    }

    public void Dispose() {
        sw.Stop();
        f(sw.Elapsed);
    }
}

Uso:

using (new DisposableStopwatch(t => Console.WriteLine("{0} elapsed", t))) {
  // do stuff that I want to measure
}

Puede intentar escribir un método de extensión para cualquier clase que esté usando (o cualquier clase base).

Me gustaría que la llamada se viera así:

Stopwatch sw = MyObject.TimedFor(1000, () => DoStuff(s));

Entonces el método de extensión:

public static Stopwatch TimedFor(this DependencyObject source, Int32 loops, Action action)
{
var sw = new Stopwatch();
sw.Start();
for (int i = 0; i < loops; ++i)
{
    action.Invoke();
}
sw.Stop();

return sw;
}

Cualquier objeto derivado de DependencyObject ahora puede llamar a TimedFor (..). La función se puede ajustar fácilmente para proporcionar valores de retorno a través de parámetros de referencia.

-

Si no desea que la funcionalidad esté vinculada a ninguna clase / objeto, puede hacer algo como:

public class Timing
{
  public static Stopwatch TimedFor(Action action, Int32 loops)
  {
    var sw = new Stopwatch();
    sw.Start();
    for (int i = 0; i < loops; ++i)
    {
      action.Invoke();
    }
    sw.Stop();

    return sw;
  }
}

Entonces podrías usarlo como:

Stopwatch sw = Timing.TimedFor(() => DoStuff(s), 1000);

De lo contrario, esta respuesta parece que tiene una habilidad "genérica" ​​decente:

¿Envolviendo el cronometraje StopWatch con un delegado o lambda?

La StopWatchclase no tiene por qué ser Disposedo Stoppedpor error. Entonces, el código más simple para cronometrar alguna acción es

public partial class With
{
    public static long Benchmark(Action action)
    {
        var stopwatch = Stopwatch.StartNew();
        action();
        stopwatch.Stop();
        return stopwatch.ElapsedMilliseconds;
    }
}

Código de llamada de muestra

public void Execute(Action action)
{
    var time = With.Benchmark(action);
    log.DebugFormat(“Did action in {0} ms.”, time);
}

No me gusta la idea de incluir las iteraciones en el StopWatchcódigo. Siempre puede crear otro método o extensión que maneje la ejecución de Niteraciones.

public partial class With
{
    public static void Iterations(int n, Action action)
    {
        for(int count = 0; count < n; count++)
            action();
    }
}

Código de llamada de muestra

public void Execute(Action action, int n)
{
    var time = With.Benchmark(With.Iterations(n, action));
    log.DebugFormat(“Did action {0} times in {1} ms.”, n, time);
}

Aquí están las versiones del método de extensión

public static class Extensions
{
    public static long Benchmark(this Action action)
    {
        return With.Benchmark(action);
    }

    public static Action Iterations(this Action action, int n)
    {
        return () => With.Iterations(n, action);
    }
}

Y código de llamada de muestra

public void Execute(Action action, int n)
{
    var time = action.Iterations(n).Benchmark()
    log.DebugFormat(“Did action {0} times in {1} ms.”, n, time);
}

Probé los métodos estáticos y los métodos de extensión (combinando iteraciones y puntos de referencia) y el delta del tiempo de ejecución esperado y el tiempo de ejecución real es <= 1 ms.

Escribí una clase simple de CodeProfiler hace algún tiempo que envolvió Stopwatch para perfilar fácilmente un método usando una Acción: http://www.improve.dk/blog/2008/04/16/profiling-code-the-easy-way

También le permitirá perfilar fácilmente el código multiproceso. El siguiente ejemplo perfilará la acción lambda con 1-16 subprocesos:

static void Main(string[] args)
{
    Action action = () =>
    {
        for (int i = 0; i < 10000000; i++)
            Math.Sqrt(i);
    };

    for(int i=1; i<=16; i++)
        Console.WriteLine(i + " thread(s):\t" + 
            CodeProfiler.ProfileAction(action, 100, i));

    Console.Read();
}

Suponiendo que solo necesita una sincronización rápida de una cosa, esto es fácil de usar.

  public static class Test {
    public static void Invoke() {
        using( SingleTimer.Start )
            Thread.Sleep( 200 );
        Console.WriteLine( SingleTimer.Elapsed );

        using( SingleTimer.Start ) {
            Thread.Sleep( 300 );
        }
        Console.WriteLine( SingleTimer.Elapsed );
    }
}

public class SingleTimer :IDisposable {
    private Stopwatch stopwatch = new Stopwatch();

    public static readonly SingleTimer timer = new SingleTimer();
    public static SingleTimer Start {
        get {
            timer.stopwatch.Reset();
            timer.stopwatch.Start();
            return timer;
        }
    }

    public void Stop() {
        stopwatch.Stop();
    }
    public void Dispose() {
        stopwatch.Stop();
    }

    public static TimeSpan Elapsed {
        get { return timer.stopwatch.Elapsed; }
    }
}

Puede sobrecargar una serie de métodos para cubrir varios casos de parámetros que tal vez desee pasar a la lambda:

public static Stopwatch MeasureTime<T>(int iterations, Action<T> action, T param)
{
    var sw = new Stopwatch();
    sw.Start();
    for (int i = 0; i < iterations; i++)
    {
        action.Invoke(param);
    }
    sw.Stop();

    return sw;
}

public static Stopwatch MeasureTime<T, K>(int iterations, Action<T, K> action, T param1, K param2)
{
    var sw = new Stopwatch();
    sw.Start();
    for (int i = 0; i < iterations; i++)
    {
        action.Invoke(param1, param2);
    }
    sw.Stop();

    return sw;
}

Alternativamente, puede usar el delegado Func si debe devolver un valor. También puede pasar una matriz (o más) de parámetros si cada iteración debe usar un valor único.

Para mí, la extensión se siente un poco más intuitiva en int, ya no es necesario crear una instancia de un cronómetro ni preocuparse por restablecerlo.

Así que tienes:

static class BenchmarkExtension {

    public static void Times(this int times, string description, Action action) {
        Stopwatch watch = new Stopwatch();
        watch.Start();
        for (int i = 0; i < times; i++) {
            action();
        }
        watch.Stop();
        Console.WriteLine("{0} ... Total time: {1}ms ({2} iterations)", 
            description,  
            watch.ElapsedMilliseconds,
            times);
    }
}

Con el uso de muestra de:

var randomStrings = Enumerable.Range(0, 10000)
    .Select(_ => Guid.NewGuid().ToString())
    .ToArray();

50.Times("Add 10,000 random strings to a Dictionary", 
    () => {
        var dict = new Dictionary<string, object>();
        foreach (var str in randomStrings) {
            dict.Add(str, null);
        }
    });

50.Times("Add 10,000 random strings to a SortedList",
    () => {
        var list = new SortedList<string, object>();
        foreach (var str in randomStrings) {
            list.Add(str, null);
        }
    });

Salida de muestra:

Add 10,000 random strings to a Dictionary ... Total time: 144ms (50 iterations)
Add 10,000 random strings to a SortedList ... Total time: 4088ms (50 iterations)

Me gusta usar las clases CodeTimer de Vance Morrison (uno de los tipos de rendimiento de .NET).

Hizo una publicación en su blog titulada " Medir el código administrado de forma rápida y sencilla: CodeTimers ".

Incluye cosas interesantes como MultiSampleCodeTimer. Hace un cálculo automático de la desviación estándar y media y también es muy fácil imprimir sus resultados.

public static class StopWatchExtensions
{
    public static async Task<TimeSpan> LogElapsedMillisecondsAsync(
        this Stopwatch stopwatch,
        ILogger logger,
        string actionName,
        Func<Task> action)
    {
        stopwatch.Reset();
        stopwatch.Start();

        await action();

        stopwatch.Stop();

        logger.LogDebug(string.Format(actionName + " completed in {0}.", stopwatch.Elapsed.ToString("hh\\:mm\\:ss")));

        return stopwatch.Elapsed;
    }
}