Mesurer le temps d'exécution en C #

Question

Je veux mesurer l'exécution d'un morceau de code, et je me demande quelle est la meilleure méthode pour ce faire est?

Option 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");

Option 2: en utilisant le Système.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");

Ce n'est pas simplement pour l'analyse comparative, sa fait partie de l'application. Le temps de la fonction prend de l'exécution des données pertinentes. Il n'a cependant pas besoin d'être atomique ou hyper-précis.

Quelle est la meilleure option pour la production de code, ou quelqu'un d'autre de quelque chose de différent et peut-être mieux?

Answer 1

L' Stopwatch classe est spécifiquement conçu pour mesurer le temps écoulé et peut (si disponible sur votre matériel) fournir une bonne granularité/précision à l'aide d'un sous-jacentes à haute-fréquence d'horloge du matériel. Donc, ce semble le meilleur choix.

Le IsHighResolution propriété peut être utilisée pour déterminer si haute résolution calendrier est disponible. Par la documentation, cette classe offre un wrapper sur les 'meilleurs' Api Win32 pour un chronométrage précis:

Plus précisément, l' Frequency domaine et GetTimestamp méthode peut être utilisée dans le lieu de la non géré Api Win32 QueryPerformanceFrequencyet QueryPerformanceCounter.

Il y a un historique détaillé sur les Api Win32 [ici] et dans MSDN docs 2.

Timer Haute Résolution

Un compteur est un terme général utilisé dans la programmation se référer à un l'incrémentation de la variable. Certains systèmes inclure une haute résolution de performance compteur qui offre une haute résolution le temps écoulé.

Si une haute résolution de performance compteur existe sur le système, vous pouvez utiliser le QueryPerformanceFrequency la fonction d'exprimer la fréquence, dans comptes par seconde. La valeur de la le comte est processeur dépend. Sur certains processeurs, par exemple, le comptage peut-être le taux du cycle de l' d'horloge du processeur.

Le QueryPerformanceCounterfonction récupère la valeur courante de la haute résolution de compteur de performance. Par l'appel de cette fonction à l' début et à la fin d'une section de code, une application utilise essentiellement le compteur en haute résolution minuterie. Par exemple, supposons que QueryPerformanceFrequencyindique que la fréquence de la haute résolution de compteur de performance est De 50 000 points par seconde. Si l' les appels d'application QueryPerformanceCounterimmédiatement avant et immédiatement après la la section de code pour être chronométré, le les valeurs du compteur peut être de 1500 compte et 3500 compte, respectivement. Ces les valeurs indiquent que .04 secondes (2000 compte) écoulé, tandis que le code exécutée.

Answer 2

Ce n'est pas seulement que StopWatch est plus précis, mais aussi que DateTime.Now donnera des résultats incorrects dans certaines circonstances.

Pensez à ce qui se passe lors du passage à l’heure avancée, par exemple: utiliser DateTime.Now peut en fait donner une réponse négative !

Answer 3

Je l'utilise généralement StopWatch pour ce genre de situation.

À partir de MSDN page:

Chronomètre

Fournit un ensemble de méthodes et de les propriétés que vous pouvez utiliser pour mesurer avec précision le temps écoulé.

Dans le post suivant, je l'utilise pour comparer le temps d'exécution de LINQ vs PLINQ:

Parallel LINQ (PLINQ) avec Visual Studio 2010

Answer 4

Ni nuira à la performance, parce que vous dites ce n'est pas que critique. Chronomètre semble plus approprié, vous êtes seulement en soustrayant de temps en temps et pas une date à partir d'un autre. Date de choses prend un peu plus de mémoire et de temps PROCESSEUR à traiter. Il y a aussi des façons de rendre le code plus propre, dans le cas où vous prévoyez de les réutiliser dans plusieurs endroits. La surcharge using vient à l'esprit. Je recherche un exemple. Ok, le code de vol à partir 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 5

Les deux vont probablement s'adapter à vos besoins, mais je dirais utiliser StopWatch. Pourquoi? Parce que ça signifiait pour la tâche que vous êtes en train de faire.

Vous avez une classe qui est construit pour retourner la date/heure actuelle, qui, comme il arrive, peut être utilisé pour la synchronisation des choses, et vous avez une classe spécifiquement conçu pour chronométrage des choses.

Dans ce cas, les différences existent vraiment si vous avez besoin d'une précision à la milliseconde (auquel cas StopWatch est plus précis), mais comme un principe général si un outil existe spécifiquement pour la tâche que vous êtes à la recherche pour alors que c'est le meilleur à utiliser.