[转]使用Stopwatch类实现高精度计时

对一段代码计时同查通常有三种方法。最简单就是用DateTime.Now来进行比较了，不过其精度只有3.3毫秒，可以通过DllImport导入QueryPerformanceFrequency和QueryPerformanceCounter，实现高精度的计时,请参考《.net平台下获取高精度时间类》。
在.NET 2.0中，新增了Stopwatch类处理计时需求，Stopwatch会优先使用高精度计时，仅当系统不支持时才会用DateTime来计时，可通过Stopwatch静态属性IsHighResolution来判断是否是高精度计时。

Stopwatch最简单的使用示例:

// 开始计时
Stopwatch watch = new Stopwatch();
watch.Start();
// 你的耗时代码
// 停止计时
watch.Stop();
//得到运行所花费的时间
Console.WriteLine(watch.Elapsed);

MSDN上的Stopwatch使用示例:

using System;
using System.Diagnostics;

namespace StopWatchSample
{
    class OperationsTimer
    {
        public static void Main()
        {
            DisplayTimerProperties();

Console.WriteLine();
            Console.WriteLine("Press the Enter key to begin:");
            Console.ReadLine();
            Console.WriteLine();

TimeOperations();
}

public static void DisplayTimerProperties()
        {
            // Display the timer frequency and resolution.
            if (Stopwatch.IsHighResolution)
            {
                Console.WriteLine("Operations timed using the system's high-resolution performance counter.");
            }
            else
            {
                Console.WriteLine("Operations timed using the DateTime class.");
            }

long frequency = Stopwatch.Frequency;
            Console.WriteLine(" Timer frequency in ticks per second = {0}",
                frequency);
            long nanosecPerTick = (1000L * 1000L * 1000L) / frequency;
            Console.WriteLine(" Timer is accurate within {0} nanoseconds",
                nanosecPerTick);
        }

private static void TimeOperations()
        {
            long nanosecPerTick = (1000L * 1000L * 1000L) / Stopwatch.Frequency;
            const long numIterations = 10000;

// Define the operation title names.
            String[] operationNames = {"Operation: Int32.Parse(\"0\")",
                                           "Operation: Int32.TryParse(\"0\")",
                                           "Operation: Int32.Parse(\"a\")",
                                           "Operation: Int32.TryParse(\"a\")"};

// Time four different implementations for parsing
// an integer from a string.

for (int operation = 0; operation <= 3; operation++)
            {
                // Define variables for operation statistics.
                long numTicks = 0;
                long numRollovers = 0;
                long maxTicks = 0;
                long minTicks = Int64.MaxValue;
                int indexFastest = -1;
                int indexSlowest = -1;
                long milliSec = 0;

Stopwatch time10kOperations = Stopwatch.StartNew();

// Run the current operation 10001 times.
// The first execution time will be tossed
// out, since it can skew the average time.

for (int i = 0; i <= numIterations; i++)
                {
                    long ticksThisTime = 0;
                    int inputNum;
                    Stopwatch timePerParse;

switch (operation)
                    {
                        case 0:
                            // Parse a valid integer using
                            // a try-catch statement.

// Start a new stopwatch timer.
timePerParse = Stopwatch.StartNew();

try
                            {
                                inputNum = Int32.Parse("0");
                            }
                            catch (FormatException)
                            {
                                inputNum = 0;
                            }

// Stop the timer, and save the
// elapsed ticks for the operation.

timePerParse.Stop();
                            ticksThisTime = timePerParse.ElapsedTicks;
                            break;
                        case 1:
                            // Parse a valid integer using
                            // the TryParse statement.

// Start a new stopwatch timer.
timePerParse = Stopwatch.StartNew();

if (!Int32.TryParse("0", out inputNum))
                            {
                                inputNum = 0;
                            }

// Stop the timer, and save the
                            // elapsed ticks for the operation.
                            timePerParse.Stop();
                            ticksThisTime = timePerParse.ElapsedTicks;
                            break;
                        case 2:
                            // Parse an invalid value using
                            // a try-catch statement.

// Start a new stopwatch timer.
timePerParse = Stopwatch.StartNew();

try
                            {
                                inputNum = Int32.Parse("a");
                            }
                            catch (FormatException)
                            {
                                inputNum = 0;
                            }

// Stop the timer, and save the
                            // elapsed ticks for the operation.
                            timePerParse.Stop();
                            ticksThisTime = timePerParse.ElapsedTicks;
                            break;
                        case 3:
                            // Parse an invalid value using
                            // the TryParse statement.

// Start a new stopwatch timer.
timePerParse = Stopwatch.StartNew();

if (!Int32.TryParse("a", out inputNum))
                            {
                                inputNum = 0;
                            }

// Stop the timer, and save the
                            // elapsed ticks for the operation.
                            timePerParse.Stop();
                            ticksThisTime = timePerParse.ElapsedTicks;
                            break;

default:
break;
}

// Skip over the time for the first operation,
                    // just in case it caused a one-time
                    // performance hit.
                    if (i == 0)
                    {
                        time10kOperations.Reset();
                        time10kOperations.Start();
                    }
                    else
                    {

// Update operation statistics
                        // for iterations 1-10001.
                        if (maxTicks < ticksThisTime)
                        {
                            indexSlowest = i;
                            maxTicks = ticksThisTime;
                        }
                        if (minTicks > ticksThisTime)
                        {
                            indexFastest = i;
                            minTicks = ticksThisTime;
                        }
                        numTicks += ticksThisTime;
                        if (numTicks < ticksThisTime)
                        {
                            // Keep track of rollovers.
                            numRollovers++;
                        }
                    }
                }

// Display the statistics for 10000 iterations.

time10kOperations.Stop();
milliSec = time10kOperations.ElapsedMilliseconds;

Console.WriteLine();
                Console.WriteLine("{0} Summary:", operationNames[operation]);
                Console.WriteLine(" Slowest time: #{0}/{1} = {2} ticks",
                    indexSlowest, numIterations, maxTicks);
                Console.WriteLine(" Fastest time: #{0}/{1} = {2} ticks",
                    indexFastest, numIterations, minTicks);
                Console.WriteLine(" Average time: {0} ticks = {1} nanoseconds",
                    numTicks / numIterations,
                    (numTicks * nanosecPerTick) / numIterations);
                Console.WriteLine(" Total time looping through {0} operations: {1} milliseconds",
                    numIterations, milliSec);
            }
        }
    }
}

msdn:《Stopwatch Class》

原文:http://www.it118.org/Specials/321869dd-98cb-431b-b6d2-82d973cd739d/3a6ef558-4596-459e-9918-93da13b3bb9b.htm