Является ли DateTime.Now лучшим способом измерения производительности функции?

Если вы хотите что-то быстрое и грязное, я 9X_datetime-manipulation бы предложил вместо этого использовать секундомер 9X_.net для большей степени точности.

Stopwatch sw = new Stopwatch();
sw.Start();
// Do Work
sw.Stop();

Console.WriteLine("Elapsed time: {0}", sw.Elapsed.TotalMilliseconds);

В качестве 9X_timer альтернативы, если вам нужно что-то более 9X_timers сложное, вам, вероятно, следует рассмотреть 9X_efficiency возможность использования стороннего профилировщика, такого 9X_speed как ANTS.

This article говорит, что прежде всего вам нужно сравнить 9X_.net-framework три альтернативы, Stopwatch, DateTime.Now И DateTime.UtcNow.

Он также показывает, что 9X_speed в некоторых случаях (когда счетчик производительности 9X_slow не существует) секундомер использует DateTime.UtcNow 9X_datetime + некоторую дополнительную обработку. Из-за 9X_timer этого очевидно, что в этом случае DateTime.UtcNow 9X_datetime-functions - лучший вариант (потому что другие используют 9X_c# его + некоторая обработка)

Однако, как оказалось, счетчик 9X_dotnet существует почти всегда - см. Explanation about high-resolution performance counter and its existence related to .NET Stopwatch?.

Вот график 9X_dotnet производительности. Обратите внимание на 9X_slow низкую стоимость UtcNow по сравнению с альтернативами:

Ось 9X_performance X - это размер данных выборки, а ось Y - относительное 9X_dotnet время примера.

Одна вещь, в которой Stopwatch лучше, - это 9X_c#.net то, что он обеспечивает измерения времени 9X_datetime-functions с более высоким разрешением. Во-вторых, это 9X_.net более объектно-ориентированный характер. Однако 9X_csharp создать объектно-ориентированную оболочку 9X_efficiency вокруг UtcNow не так сложно.

Полезно втиснуть код бенчмаркинга в служебный 9X_c#.net класс/метод. Класс StopWatch не обязательно должен 9X_c# быть Disposed или Stopped при ошибке. Итак, самый простой 9X_datetime-manipulation код для времени некоторого действия

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

Вот 9X_c#.net версия метода расширения

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

И пример кода вызова

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

Функциональность stopwatch была бы лучше (более высокая 9X_timer точность). Я бы также порекомендовал просто 9X_speed загрузить один из популярных профилировщиков 9X_efficiency (DotTrace и ANTS — те, которыми я пользовался чаще всего… бесплатная 9X_slow пробная версия DotTrace полностью функциональна 9X_csharp и не ворчит, как некоторые из другие).

Используйте класс System.Diagnostics.Stopwatch.

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

// Do some code.

sw.Stop();

// sw.ElapsedMilliseconds = the time your "do some code" took.

9X_.net-framework

То же самое Секундомер, это намного лучше.

Что 9X_c# касается измерения производительности, вы 9X_dot-net также должны проверить, является ли ваш 9X_csharp «// Some Execution Process» очень коротким 9X_dotnet процессом.

Также имейте в виду, что первый 9X_dot-net запуск вашего "// Some Execution Process" может 9X_c-sharp быть намного медленнее, чем последующие 9X_datetime-functions запуски.

Обычно я тестирую метод, запуская 9X_dotnet его 1000 раз или 1000000 раз в цикле, и 9X_c-sharp получаю гораздо более точные данные, чем 9X_csharp один раз.

Все это отличные способы измерения времени, но 9X_efficiency это лишь косвенный способ найти узкие места.

Самый 9X_dotnet прямой способ найти узкое место в потоке 9X_.net - запустить его, и пока он делает то, что 9X_timer заставляет вас ждать, остановите его с помощью 9X_c# клавиши паузы или прерывания. Сделайте это 9X_c#.net несколько раз. Если ваше узкое место занимает 9X_datetime X% времени, X% - это вероятность того, что 9X_.net вы поймаете его в действии на каждом снимке.

Here's a more complete explanation of how and why it works

@Sean Chambers

К вашему сведению, класс .NET Timer не 9X_dot-net предназначен для диагностики, он генерирует 9X_timer события с заданным интервалом, например 9X_datetime-manipulation так (от MSDN):

System.Timers.Timer aTimer;
public static void Main()
{
    // Create a timer with a ten second interval.
    aTimer = new System.Timers.Timer(10000);

    // Hook up the Elapsed event for the timer.
    aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);

    // Set the Interval to 2 seconds (2000 milliseconds).
    aTimer.Interval = 2000;
    aTimer.Enabled = true;

    Console.WriteLine("Press the Enter key to exit the program.");
    Console.ReadLine();
}

// Specify what you want to happen when the Elapsed event is 
// raised.
private static void OnTimedEvent(object source, ElapsedEventArgs e)
{
    Console.WriteLine("The Elapsed event was raised at {0}", e.SignalTime);
}

Так что это на самом деле не поможет 9X_efficiency вам узнать, сколько времени что-то заняло, просто 9X_csharp то, что прошло определенное количество времени.

Таймер 9X_datetime также представлен как элемент управления 9X_performance в System.Windows.Forms... вы можете найти 9X_c#.net его в своем наборе инструментов дизайнера 9X_speed в VS05/VS08

Это правильный способ:

using System;
using System.Diagnostics;

class Program
{
    public static void Main()
    {
        Stopwatch stopWatch = Stopwatch.StartNew();

            // some other code

        stopWatch.Stop();

        // this not correct to get full timer resolution
        Console.WriteLine("{0} ms", stopWatch.ElapsedMilliseconds);

        // Correct way to get accurate high precision timing
        Console.WriteLine("{0} ms", stopWatch.Elapsed.TotalMilliseconds);
    }
}

Дополнительную информацию 9X_dotnet см. на странице Use Stopwatch instead of DataTime for getting accurate performance counter.

Visual Studio Team System имеет некоторые функции, которые могут 9X_speed помочь в решении этой проблемы. По сути, вы 9X_c# можете писать модульные тесты и смешивать 9X_datetime-manipulation их в разных сценариях для запуска с вашим 9X_dot-net программным обеспечением в рамках стресс-теста 9X_slow или нагрузочного теста. Это может помочь 9X_timers определить области кода, которые больше 9X_slow всего влияют на производительность ваших 9X_datetime-manipulation приложений.

Группа Microsoft "Шаблоны 9X_dotnet и практики" имеет некоторые рекомендации 9X_dot-net в Visual Studio Team System Performance Testing Guidance.

Я только что нашел сообщение в блоге Вэнса 9X_.net-framework Моррисона о том, что a CodeTimer class он написал, что это 9X_c#.net упрощает использование StopWatch и делает некоторые 9X_slow полезные вещи на стороне.

Я использую в своих программах класс StopWatch, как 9X_dot-net показано здесь.

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


// Critical lines of code

long elapsedMs = sw.Elapsed.TotalMilliseconds;

Я очень мало проверял производительность 9X_c#.net такого рода (я склонен просто думать «это 9X_dot-net медленно, сделайте это быстрее»), поэтому 9X_c#.net я почти всегда придерживался этого.

Google 9X_c-sharp показывает множество ресурсов/статей для 9X_datetime проверки производительности.

Многие упоминают 9X_c#.net об использовании pinvoke для получения информации 9X_datetime-manipulation о производительности. Во многих материалах, которые 9X_timer я изучаю, упоминается только использование 9X_datetime perfmon.

Изменить:

Видел выступления Секундомера.. Красиво! Я 9X_dot-net кое-чему научился :)

This looks like a good article

Это недостаточно профессионально:

Stopwatch sw = Stopwatch.StartNew();
PerformWork();
sw.Stop();

Console.WriteLine("Time taken: {0}ms", sw.Elapsed.TotalMilliseconds);

Более надежная 9X_.net-framework версия:

PerformWork();

int repeat = 1000;

Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < repeat; i++)
{
   PerformWork();
}

sw.Stop();

Console.WriteLine("Time taken: {0}ms", sw.Elapsed.TotalMilliseconds / repeat);

В моем реальном коде я добавлю вызов 9X_c# GC.Collect для изменения управляемой кучи 9X_slow до известного состояния и добавлю вызов 9X_datetime-manipulation сна, чтобы можно было легко разделить различные 9X_c-sharp интервалы кода в профиле ETW.