Envolvendo StopWatch tempo com um delegado ou lambda?
https://stackoverflow.com/questions/232848
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Eu estou escrevendo código como este, fazendo um pouco de tempo rápido e sujo:
var sw = new Stopwatch();
sw.Start();
for (int i = 0; i < 1000; i++)
{
b = DoStuff(s);
}
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);
Certamente há uma maneira de chamar este pedaço de código de tempo como uma fantasia-schmancy .NET 3.0 lambda em vez de (Deus me livre) cortando e colando-o algumas vezes e substituindo o DoStuff(s) com DoSomethingElse(s) ?
Eu sei que pode ser feito como um Delegate mas eu estou querendo saber sobre a maneira como lambda.
Solução
Como sobre como estender a classe 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;
}
}
Em seguida, chamá-lo assim:
var s = new Stopwatch();
Console.WriteLine(s.Time(() => DoStuff(), 1000));
Você pode adicionar uma outra sobrecarga que omite o parâmetro "iterações" e chama esta versão com algum valor padrão (como 1000).
Outras dicas
Aqui está o que eu tenho usado:
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
}
Você poderia tentar escrever um método de extensão para qualquer classe que você está usando (ou qualquer classe base).
Gostaria de ter a aparência de chamadas como:
Stopwatch sw = MyObject.TimedFor(1000, () => DoStuff(s));
Em seguida, o método de extensão:
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;
}
Qualquer objeto que deriva de DependencyObject pode agora chamar TimedFor (..). A função pode ser facilmente ajustado para fornecer valores de retorno via parâmetros ref.
-
Se você não queria que a funcionalidade a ser vinculado a qualquer classe / objeto que você poderia fazer 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;
}
}
Em seguida, você pode usá-lo como:
Stopwatch sw = Timing.TimedFor(() => DoStuff(s), 1000);
Se isso falhar, esta resposta parece que tem alguma decente capacidade "genérico":
A classe StopWatch não precisa ser Disposed ou Stopped em erro. Assim, o código mais simples de tempo alguns action é
public partial class With
{
public static long Benchmark(Action action)
{
var stopwatch = Stopwatch.StartNew();
action();
stopwatch.Stop();
return stopwatch.ElapsedMilliseconds;
}
}
código de chamada Amostra
public void Execute(Action action)
{
var time = With.Benchmark(action);
log.DebugFormat(“Did action in {0} ms.”, time);
}
Eu não gosto da idéia de incluir as iterações no código StopWatch. Você sempre pode criar outro método ou extensão que alças executar iterações N.
public partial class With
{
public static void Iterations(int n, Action action)
{
for(int count = 0; count < n; count++)
action();
}
}
código de chamada Amostra
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);
}
Aqui estão as versões do método de extensão
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);
}
}
E código de chamada de amostra
public void Execute(Action action, int n)
{
var time = action.Iterations(n).Benchmark()
log.DebugFormat(“Did action {0} times in {1} ms.”, n, time);
}
Eu testei os métodos estáticos e métodos de extensão (combinando iterações e de referência) e o delta de tempo de execução esperado e tempo de execução real é <= 1 ms.
Eu escrevi uma classe CodeProfiler simples há algum tempo que envolveu Cronômetro facilmente o perfil de um método que utiliza uma ação: http://www.improve.dk/ blogue / 2008/04/16 / perfilar-code-the-fácil-way
Ele também vai facilmente permitem traçar o perfil do código multithread. O exemplo a seguir o perfil do lambda ação com 1-16 tópicos:
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();
}
Assumindo que você só precisa de um tempo rápido de uma coisa isso é 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; }
}
}
Você pode sobrecarregar uma série de métodos para cobrir vários casos de parâmetros que você pode querer passar para o 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;
}
Como alternativa, você pode usar o delegado Func se deve retornar um valor. Você também pode passar em uma matriz (ou mais) dos parâmetros, se cada iteração deve usar um valor único.
Para mim a extensão sente um pouco mais intuitiva em int, você não precisa mais para instanciar um cronômetro ou se preocupar com redefini-lo.
Então você tem:
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);
}
}
Com o uso de amostra:
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);
}
});
Exemplo de saída:
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)
Eu gosto de usar as classes CodeTimer de Vance Morrison (um dos caras de desempenho da NET).
Ele fez um post sobre em seu blog intitulado " medição código gerenciado de forma rápida e easiliy:. CodeTimers "
Ele inclui coisas legais, como um MultiSampleCodeTimer. Ele faz o cálculo automático da média e desvio padrão e sua também muito fácil de imprimir os seus resultados.
