用委托或 lambda 包装秒表计时

本文关键字：包装 lambda | 更新日期: 2023-09-27 17:47:22

我正在编写这样的代码，做一些快速而肮脏的计时：

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

当然，有一种方法可以将这部分计时代码称为花哨的 .NET 3.0 lambda，而不是（上帝保佑）剪切和粘贴几次并用 DoSomethingElse(s) 替换DoStuff(s)？

我知道它可以作为Delegate来完成，但我想知道 lambda 的方式。

用委托或 lambda 包装秒表计时

扩展秒表类怎么样？

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

然后这样称呼它：

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

您可以添加另一个重载，该重载省略"迭代"参数并使用某个默认值（如 1000）调用此版本。

这是我一直在使用的：

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

用法：

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

您可以尝试为正在使用的任何类（或任何基类）编写扩展方法。

我会让电话看起来像：

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

那么扩展方法： 

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

任何派生自 DependencyObject 的对象现在都可以调用 TimedFor（..）。该函数可以轻松调整，以通过 ref 参数提供返回值。

--

如果您不希望将功能绑定到任何类/对象，您可以执行以下操作：

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

然后你可以像这样使用它：

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

如果做不到这一点，这个答案看起来有一些不错的"通用"能力：

用委托或 lambda 包装秒表计时？

StopWatch类不需要

在出错时Disposed或Stopped。 因此，对某些操作进行计时的最简单代码是

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

示例调用代码

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

我不喜欢将迭代包含在StopWatch代码中的想法。始终可以创建处理执行N迭代的另一个方法或扩展。

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

示例调用代码

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

以下是扩展方法版本

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

和示例调用代码

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

我测试了静态方法和扩展方法（结合迭代和基准测试），预期执行时间和实际执行时间的增量为 <= 1 毫秒。

前段时间我写了一个简单的 CodeProfiler 类，它包装了秒表，以便使用 Action 轻松分析方法：http://www.improve.dk/blog/2008/04/16/profiling-code-the-easy-way

它还允许您轻松分析多线程代码。以下示例将使用 1-16 个线程分析操作 lambda：

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

假设您只需要快速计时一件事，这很容易使用。 

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

您可以重载许多方法来涵盖您可能希望传递给 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;
}

或者，如果 Func 委托必须返回值，则可以使用 Func 委托。如果每次迭代都必须使用唯一值，则还可以传入参数数组（或多个）。

对我来说

，扩展在int上感觉更直观一些，您不再需要实例化秒表或担心重置它。

所以你有： 

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

示例用法为： 

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

示例输出： 

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)
我喜欢

使用Vance Morrison（.NET的性能家伙之一）的CodeTimer类。

他在自己的博客上发表了一篇题为"快速轻松地测量托管代码：CodeTimers"的文章。

它包括很酷的东西，如MultiSampleCodeTimer。它可以自动计算平均值和标准偏差，并且也很容易打印出您的结果。

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;
    }
}
相关文章：