Comment mesurer les performances du code dans .NET?

La Stopwatch classe, qui est disponible depuis .NET 2.0, est la meilleure façon d'aller pour cela. C'est un très haut de compteur de performance précis pour une fraction de milliseconde.
Jetez un oeil à la La documentation MSDN, ce qui est assez clair.

EDIT: Comme suggéré précédemment, il est également conseillé d'exécuter votre code un certain nombre de fois afin d'obtenir une moyenne raisonnable de temps.

- Je trouver ces très utiles

http://accelero.codeplex.com/SourceControl/changeset/view/22633#290971
http://accelero.codeplex.com/SourceControl/changeset/view/22633#290973
http://accelero.codeplex.com/SourceControl/changeset/view/22633#290972

TickTimer est un coupé copie de Chronomètre démarre quand construits et ne prend pas en charge le redémarrage. Il sera également vous informer si le matériel actuel ne prend pas en charge la résolution de synchronisation (Chronomètre avale ce problème)

Donc ce

var tickTimer = new TickTimer();
//call a method that takes some time
DoStuff();
tickTimer.Stop();
Debug.WriteLine("Elapsed HighResElapsedTicks " + tickTimer.HighResElapsedTicks);
Debug.WriteLine("Elapsed DateTimeElapsedTicks " + tickTimer.DateTimeElapsedTicks);
Debug.WriteLine("Elapsed ElapsedMilliseconds " + tickTimer.ElapsedMilliseconds);
Debug.WriteLine("Start Time " + new DateTime(tickTimer.DateTimeUtcStartTicks).ToLocalTime().ToLongTimeString());

sera de sortie ce

Elapsed HighResElapsedTicks 10022886
Elapsed DateTimeElapsedTicks 41896
Elapsed ElapsedMilliseconds 4.18966178849554
Start Time 11:44:58

DebugTimer est un wrapper pour TickTimer qui écrira le résultat de Débogage. (note: il prend en charge le modèle Jetable)

Donc ce

using (new DebugTimer("DoStuff"))
{
    //call a method that takes some time
    DoStuff();
}

sera de sortie ce à la fenêtre de débogage

DoStuff: Total 3.6299 ms

IterationDebugTimer est pour chronométrer combien de temps il faut pour exécuter une opération plusieurs fois et écrire le résultat de Débogage. Il permettra également d'effectuer un premier cycle qui n'est pas inclus de manière à ignorer les temps de démarrage. (note: il prend en charge le modèle Jetable)

Donc ce

int x;
using (var iterationDebugTimer = new IterationDebugTimer("Add", 100000))
{
    iterationDebugTimer.Run(() =>
    {
        x = 1+4;
    });
}

Sera de sortie ce

Add: Iterations 100000 
Total 1.198540 ms 
Single 0.000012 ms

Utiliser un vrai profiler comme dotTrace.

Vous pouvez utiliser le Stopwatch, en supposant que vous utilisez .NET 2.0 ou plus récente.

System.Diagnostics.Stopwatch.StartNew();

La Stopwatch classe a aussi des publique champ en lecture seule IsHighResolution qui vous permettra de savoir si le chronomètre est basé sur une haute résolution de compteur de performance. Si ce n'est pas, il est basé sur le système de minuterie.

Je ne suis pas sûr de ce qu'il faut pour que le chronomètre à être basé sur haute résolution de compteur de performance. Il y a quelques appels de l'API, mais je me dis que si le chronomètre n'a pas une haute résolution, l'API n'est probablement pas là.

Voici une belle écriture à la MSDN sur la façon de Mettre en œuvre une Permanence de la mise à Jour, de Temps à Haute Résolution Fournisseur pour Windows

Voici la l'exemple de code source pour l'article (C++).

Ce projet de code article montre comment utiliser la haute performance de la minuterie de mesure de la vitesse d'exécution de votre code:

http://www.codeproject.com/KB/cs/highperformancetimercshar.aspx

Ici vous pouvez trouver un certain nombre de l'open source C# profileurs:

http://csharp-source.net/open-source/profilers

Jetables style Stopwatch qui fonctionne le mieux pour moi.

class VWatch : IDisposable {
    Stopwatch watch = new Stopwatch();
    public VWatch() {
        this.watch.Start();
    }
    public void Dispose() {
        this.watch.Stop();
        Console.WriteLine("Finished. Elapsed={0}", this.watch.Elapsed);
    }
}

Et puis:

using (new VWatch()) {
    ///do something for time measurement
}

Parfois, il peut être préférable de chercher à comprendre pourquoi vous avez besoin de temps de l'opération? Est-il lent? Ou vous êtes simplement curieux? Première règle de l'optimisation est "ne fais pas cela". Ainsi, en fonction de ce que vous êtes réellement en mesure, pourrait changer l'opinion sur ce qui est le meilleur outil adapté à la tâche.

J'ai fait une extension qui renvoie millisecondes à partir de tiques.

public static int GetTotalRunningTimeInMilliseconds(this DateTime start)
{
    var endTicks = DateTime.Now.Ticks - start.Ticks;
    return TimeSpan.FromTicks(endTicks).Milliseconds;
}

Utilisation:

 var start = DateTime.Now;

 //...your long running code here

 var endTime = start.GetTotalRunningTimeInMilliseconds();

Pour mesurer le rendement de la différence entre les mesures-je utiliser cette classe. Le Chronomètre de la classe n'a pas le Split méthode.

///<summary>
///Stopwatch like class that keeps track of timelapses.
///Probably low-res because of the usage of DateTime.
///</summary>
public class ChronoMeter
{
///<summary>
///The name given when the Chronometer was constructed.
///</summary>
public string Name { get; private set; }
///<summary>
///The moment in time Start was called.
///</summary>
public DateTime Started { get; private set; }
///<summary>
///All time recordings are added to this list by calling Split and Stop.
///</summary>
public List<ChronoRecord> Records { get; private set; }
private readonly Stopwatch _stopWatch = new Stopwatch();
private bool _hasBeenStopped = false;
///<summary>
///Constrcutor
///</summary>
///<param name="pName">The name is used in logging</param>
///<param name="pLoggingType">The type of logging appriate for the information yielded by this time recording.</param>
public ChronoMeter(string pName)
{
Name = pName;
Records = new List<ChronoRecord>();
}
///<summary>
///Not calling Stop is bad practise. Therefore a little safety net zo the end is still recorderd.
///Keep in mind that the garbase collector invokes the destructor, so the moment of time probably doesn't make much sense.
///It is more to notify that you should have used Stop for the latest split.
///</summary>
~ChronoMeter()
{
if (!_hasBeenStopped)
{
Stop("Destructor safety net");
}
}
///<summary>
///TimeElapsedSinceStart of a ChronoRecord is relative to the moment ChronoMeter was started by calling this function.
///</summary>
public void Start()
{
_stopWatch.Start();
Started = DateTime.Now;
}
///<summary>
///Splits the timerecording and add a record of this moment to the list of split records.
///</summary>
///<param name="pSplitName"></param>
public void Split(string pSplitName)
{
_stopWatch.Stop();
var created = Started + _stopWatch.Elapsed;
var previousRecord = Records.LastOrDefault();
Records.Add(new ChronoRecord(pSplitName, Started, created, previousRecord));
_stopWatch.Start();
}
///<summary>
///Indicates you are done and the records will be written to the log.
///</summary>
public void Stop(string pSplitName)
{
Split(pSplitName);
_stopWatch.Stop();
_hasBeenStopped = true;
}
public class ChronoRecord
{
public string Name { get; private set; }
public TimeSpan TimeElapsedSinceStart { get; private set; }
public TimeSpan TimeElapsedSincePrevious { get; private set; }
public DateTime Start { get; private set; }
public DateTime Created { get; private set; }
public ChronoRecord(string pName, DateTime pStartDateTime, DateTime pCreated, ChronoRecord pPreviousRecord=null)
{
if (pCreated == default(DateTime)) //Ignore DefaultDateTimeComparison
{
pCreated = DateTime.Now;
}
Created = pCreated;
Name = pName;
Start = pStartDateTime;
TimeElapsedSinceStart = Created - Start;
if (pPreviousRecord != null)
{
TimeElapsedSincePrevious = Created - pPreviousRecord.Created;
}
else
{
TimeElapsedSincePrevious = TimeElapsedSinceStart;
}
}
}
}