文章目录

• 1、调用WIN API中的GetTickCount【误差：15ms左右】
• • 用法：
  • 延时函数测试【单位：毫秒】：
• 2、调用WIN API中的timeGetTime【推荐】
• • 用法：
  • 延时函数测试【单位：毫秒】：
• 3、调用.net自带的方法System.Environment.TickCount
• • 用法：
  • 延时函数测试【单位：毫秒】：
• 4、调用WIN API中的QueryPerformanceCounter
• • 用法：
  • 延时函数测试【单位：毫秒（也可以延时微秒）】：
• 5、使用.net的System.Diagnostics.Stopwatch类【推荐】
• • 用法：
  • 测试延时函数【单位：毫秒（也可以延时微妙）】：
• 6、使用.net的DateTime.Ticks类【不推荐，延时效果很差】
• • 延时函数测试【单位：微秒Microseconds】：
• 参考：

在Visual Studio写代码时的提示：

综合网上的一些文章，精确计时主要有以下几种方式：

1、调用WIN API中的GetTickCount【误差：15ms左右】

[DllImport("kernel32")]
static extern uint GetTickCount();

从操作系统启动到现在所经过的毫秒数，精度为1毫秒，经简单测试发现其实误差在大约在15ms左右
缺点：返回值是uint,最大值是2的32次方，因此如果服务器连续开机大约49.71天以后，该方法取得的返回值会归零。

用法：

uint s1 = GetTickCount();
Thread.Sleep(2719);
Console.WriteLine(GetTickCount() - s1);  //单位毫秒

延时函数测试【单位：毫秒】：

 using System;
using System.Runtime.InteropServices;

public class Example
{
    [DllImport("kernel32")]
    static extern uint GetTickCount();

    public static void Main()
    {
        Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff"));
        delay_ms(10);
        Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff"));
        Console.ReadLine();
    }

    public static void delay_ms(uint delay_time)
    {
        uint time_start = GetTickCount();
        uint time_stamp = 0;
        do
        {
            time_stamp = GetTickCount() - time_start;
        }
        while (time_stamp < delay_time);
    }
}

2、调用WIN API中的timeGetTime【推荐】

[DllImport("winmm")]
static extern uint timeGetTime();

常用于多媒体定时器中，与GetTickCount类似，也是返回操作系统启动到现在所经过的毫秒数，精度为1毫秒。

一般默认的精度不止1毫秒（不同操作系统有所不同），需要调用timeBeginPeriod与timeEndPeriod来设置精度。

[DllImport("winmm")]
static extern void timeBeginPeriod(int t);
[DllImport("winmm")]
static extern void timeEndPeriod(int t);

缺点：与GetTickCount一样，受返回值的最大位数限制。

用法：

timeBeginPeriod(1);
uint start = timeGetTime();
Thread.Sleep(2719);
Console.WriteLine(timeGetTime() - start);  //单位毫秒
timeEndPeriod(1);

延时函数测试【单位：毫秒】：

 using System;
using System.Runtime.InteropServices;

namespace ConsoleApp2
{
    class Program
    {
        [DllImport("winmm")]
        public static extern uint timeGetTime();

        [DllImport("winmm")]
        private static extern void timeBeginPeriod(int t);
        [DllImport("winmm")]
        static extern void timeEndPeriod(int t);
        static void Main(string[] args)
        {
            Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff"));
            delay_ms(10);
            Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff"));
            Console.ReadLine();

            Console.ReadLine();
        }
        public static void delay_ms(uint delay_time)
        {
            uint time_start = timeGetTime();
            uint time_stamp = 0;
            do
            {
                time_stamp = timeGetTime() - time_start;
            }
            while (time_stamp < delay_time);
        }
    }
}

3、调用.net自带的方法System.Environment.TickCount

获取系统启动后经过的毫秒数。
经反编译猜测它可能也是调用的GetTickCount，但是它的返回值是int，而GetTickCount与timeGetTime方法的原型中返回值是DWORD，对应C#中的uint，难道.NET对System.Environment.TickCount另外还做了什么处理么？

缺点：与GetTickCount一样，受返回值的最大位数限制。

用法：

int aa = System.Environment.TickCount;
Thread.Sleep(2719);
Console.WriteLine(System.Environment.TickCount - aa); //单位毫秒 

【注：】
经过测试，发现GetTickCount、System.Environment.TickCount也可以用timeBeginPeriod与timeEndPeriod来设置精度，最高可将精度提高到1毫秒。不知是什么原因？

延时函数测试【单位：毫秒】：

 using System;

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff"));
            delay_ms(10);
            Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff"));
            Console.ReadLine();
        }
        public static void delay_ms(int delay_time)
        {
            int time_start = System.Environment.TickCount;
            int time_stamp = 0;
            do
            {
                time_stamp = System.Environment.TickCount - time_start;
            }
            while (time_stamp < delay_time);
        }
    }
}

4、调用WIN API中的QueryPerformanceCounter

[DllImport("kernel32.dll ")]
static extern bool QueryPerformanceCounter(ref   long lpPerformanceCount);

用于得到高精度计时器（如果存在这样的计时器）的值。微软对这个API解释就是每秒钟某个计数器增长的数值。
如果安装的硬件不支持高精度计时器,函数将返回false。

需要配合另一个API函数QueryPerformanceFrequency。

[DllImport("kernel32")]
static extern bool QueryPerformanceFrequency(ref long PerformanceFrequency);

QueryPerformanceFrequency返回硬件支持的高精度计数器的频率，如果安装的硬件不支持高精度计时器,函数将返回false。

用法：

long a = 0;
QueryPerformanceFrequency(ref a);
long b = 0, c = 0;
QueryPerformanceCounter(ref b);
Thread.Sleep(2719);
QueryPerformanceCounter(ref c);
Console.WriteLine((c - b) / (decimal)a);  //单位秒

精度为百万分之一秒。而且由于是long型，所以不存在上面几个API位数不够的问题。

缺点：在一篇文章看到，该API在节能模式的时候结果偏慢，超频模式的时候又偏快，而且用电池和接电源的时候效果还不一样（笔记本）

未经过超频等测试，如果是真的，那该API出来的结果就可能不准。

延时函数测试【单位：毫秒（也可以延时微秒）】：

using System;
using System.Runtime.InteropServices;

namespace ConsoleApp1
{
    class Program
    {
        [DllImport("kernel32.dll")]
        extern static short QueryPerformanceCounter(ref long x);
        [DllImport("kernel32.dll")]
        extern static short QueryPerformanceFrequency(ref long x);

        static void Main(string[] args)
        {
            Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff"));
            delay_ms(10);
            Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff"));
            Console.ReadLine();
            Console.ReadLine();
        }

   
        public static void delay_ms(long delay_Time)
        {
            long stop_Value = 0;
            long start_Value = 0;
            long freq = 0;
            long stamp_Value = 0;

            QueryPerformanceFrequency(ref freq);  //获取CPU频率
            long delay_count = delay_Time * freq / 1000;   //这里写成1000000就是微秒，写成1000就是毫秒
            QueryPerformanceCounter(ref start_Value); //获取初始前值

            do
            {
                QueryPerformanceCounter(ref stop_Value);//获取终止变量值
                stamp_Value = stop_Value - start_Value;

            }
            while (stamp_Value < delay_count);
        }
    }
}

5、使用.net的System.Diagnostics.Stopwatch类【推荐】

Stopwatch 在基础计时器机制中对计时器的刻度进行计数，从而测量运行时间。如果安装的硬件和操作系统支持高分辨率性能的计数器，则 Stopwatch 类将使用该计数器来测量运行时间；否则，Stopwatch 类将使用系统计数器来测量运行时间。使用 Frequency 和 IsHighResolution 两个静态字段可以确定实现 Stopwatch 计时的精度和分辨率。

实际上它里面就是将QueryPerformanceCounter、QueryPerformanceFrequency两个WIN API封装了一下，如果硬件支持高精度，就调用QueryPerformanceCounter，如果不支持就用DateTime.Ticks来计算。

用法：

Stopwatch sw = new Stopwatch();
sw.Start();
Thread.Sleep(2719);
sw.Stop();
Console.WriteLine(sw.ElapsedTicks / (decimal)Stopwatch.Frequency);

测试延时函数【单位：毫秒（也可以延时微妙）】：

 using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int i = 0; i < 20; i++)
            {
                double result = delayUs(0.005);//延时0.005ms,即5us
                Console.WriteLine(result);
            }
          
            Console.ReadLine();
        }

        /// <summary>
        ///  微秒延时
        /// </summary>
        /// <param name="time">延时时间,单位:ms</param>
        /// <returns></returns>
        public static double delayUs(double time)
        {
            System.Diagnostics.Stopwatch stopTime = new System.Diagnostics.Stopwatch();

            stopTime.Start();
            while (stopTime.Elapsed.TotalMilliseconds < time) { }
            stopTime.Stop();

            return stopTime.Elapsed.TotalMilliseconds;
        }

    }
}

6、使用.net的DateTime.Ticks类【不推荐，延时效果很差】

DateTime.Ticks：表示0001 年 1 月 1 日午夜 12:00:00 以来所经历的 100 纳秒数，即Ticks的属性为100纳秒（1Ticks = 0.0001毫秒）。

延时函数测试【单位：微秒Microseconds】：

//延时，单位：微妙us
 public static void delay(long t)
        {
            long b = DateTime.Now.Ticks / 10;
            long e = 0; long c = 0; ;
            do
            {
                e = DateTime.Now.Ticks / 10;
                c = e - b;               
            }
            while (c < t);
        }

参考：

https://www.cnblogs.com/HappyEDay/p/5780312.html