Environment.TickCount vs DateTime.Now

Question

Est-il acceptable d'utiliser Environment.TickCount pour calculer des intervalles de temps?

 int start = Environment.TickCount;
// Do stuff
int duration = Environment.TickCount - start;
Console.WriteLine("That took " + duration " ms");
 

Parce que TickCount est signé et reviendra au bout de 25 jours (il faut 50 jours pour atteindre les 32 bits, mais vous devez supprimer le bit signé pour donner un sens au calcul), il semble trop risqué d'être utile. .

J'utilise DateTime.Now à la place. Est-ce la meilleure façon de faire cela?

 DateTime start = DateTime.Now;
// Do stuff
TimeSpan duration = DateTime.Now - start;
Console.WriteLine("That took " + duration.TotalMilliseconds + " ms");
 

Answer 1

De l'environnement.TickCount est basé sur GetTickCount() WinAPI fonction. C'est en millisecondes Mais la précision est d'environ 15.6 mme. Si vous ne pouvez pas mesurer plus courts intervalles de temps (ou vous aurez 0)

Remarque: La valeur retournée est Int32, si ce compteur survole ~49,7 jours. Vous ne devriez pas l'utiliser pour mesurer ces longs intervalles.

DateTime.Les tiques est basé sur GetSystemTimeAsFileTime() WinAPI fonction. C'est dans 100 nanosecondes (dixièmes de microsoconds). La réelle précision de DateTime.Les tiques dépend du système. Sur XP, l'incrément de l'horloge du système est d'environ 15.6 ms, le même que dans l'Environnement.TickCount. Sur Windows 7, dont la précision est de 1 ms (alors que Environemnt.TickCount est encore 15.6 ms), cependant, si une économie d'énergie de système est utilisé (généralement sur les ordinateurs portables) ça peut aller jusqu'à 15,6 mme.

Le chronomètre est basé sur QueryPerformanceCounter() WinAPI fonction (mais si haute résolution de compteur de performance n'est pas pris en charge par votre système, DateTime.Les tiques est utilisé)

Avant d'utiliser le Chronomètre avis deux problèmes:

• il peut être peu fiables sur les systèmes multiprocesseurs (voir MS kb895980, kb896256)
• il peut être peu fiable si la fréquence du PROCESSEUR varie (lire cet article)

Vous pouvez évaluer la précision de votre système avec test simple:

static void Main(string[] args)
{
    int xcnt = 0;
    long xdelta, xstart;
    xstart = DateTime.UtcNow.Ticks;
    do {
        xdelta = DateTime.UtcNow.Ticks - xstart;
        xcnt++;
    } while (xdelta == 0);

    Console.WriteLine("DateTime:\t{0} ms, in {1} cycles", xdelta / (10000.0), xcnt);

    int ycnt = 0, ystart;
    long ydelta;
    ystart = Environment.TickCount;
    do {
        ydelta = Environment.TickCount - ystart;
        ycnt++;
    } while (ydelta == 0);

    Console.WriteLine("Environment:\t{0} ms, in {1} cycles ", ydelta, ycnt);


    Stopwatch sw = new Stopwatch();
    int zcnt = 0;
    long zstart, zdelta;

    sw.Start();
    zstart = sw.ElapsedTicks; // This minimizes the difference (opposed to just using 0)
    do {
        zdelta = sw.ElapsedTicks - zstart;
        zcnt++;
    } while (zdelta == 0);
    sw.Stop();

    Console.WriteLine("StopWatch:\t{0} ms, in {1} cycles", (zdelta * 1000.0) / Stopwatch.Frequency, zcnt);
    Console.ReadKey();
}

Answer 2

Utilisez la classe Stopwatch. Il existe un exemple décent sur msdn: http://msdn.microsoft.com/en-us/library/system.diagnostics.stopwatch.aspx

     Stopwatch stopWatch = Stopwatch.StartNew();
    Thread.Sleep(10000);
    stopWatch.Stop();
    // Get the elapsed time as a TimeSpan value.
    TimeSpan ts = stopWatch.Elapsed;
 

Answer 3

Vous voulez probablement System.Diagnostics.StopWatch .

Answer 4

Utilisation

 System.Diagnostics.Stopwatch
 

Il a une propriété appelée

 EllapsedMilliseconds