One quick solution is to wrap the API function within a class, but this unfortunately adds more overhead to the call and thus reduces the achievable accuracy even future. I tried to address the convenience and accuracy issues by providing a customized class. It enhances the accuracy by measuring the average overhead associated with the call. This is shown as follows (in the constructor):

public PerformanceCounter() {

int r = QueryPerformanceCounter(ref counterStart);

if (r == 0) throw new Exception("High-resolution counter not supported.");

Start();

End();

for (int i = 0 ; i < 100000 ; i++) {

Start(); avgOverHead += End();

}

avgOverHead = (long) ((double) avgOverHead / 100000.0);

}

public void Start() {

QueryPerformanceCounter(ref counterStart);

}

public long End() {

QueryPerformanceCounter(ref counterEnd);

return counterEnd - counterStart;

}

Every time when the class is initialized, the API function is called continuously for 100000 times and the average call overhead is obtained. A function TimeElapsed is provided to calculate the time span between the Start() and the End() call. Note that the first round of the Start() and End() call is ignored because it typically takes longer for the CLR to load the code for the first time.

public double TimeElapsed(string unit) {

double diff = counterEnd - counterStart - avgOverHead;

double seconds = diff / ((double) Frequency);

switch (unit.Trim().ToUpper()) {

case "S": return seconds;

case "MS": return seconds * 1000.0;

case "US": return seconds * 1000000.0;

case "NS": return seconds * 1000000000.0;

default: throw new Exception("Unit " + unit + " not supported.");

}

}

The TimeElapsed function takes the call latency into consideration. It also simplifies the result by converting it to the specified measurement unit (second, millisecond, etc). The following code sample shows how to use the utility:

PerformanceCounter p = new PerformanceCounter();

p.Start();

{code to be timed goes here}

p.End();

Console.WriteLine(p.TimeElapsed("ms"));