方法一：System.Diagnostics.Stopwatch【相对方法二精度更高，也更稳定些】

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;
运行结果：【我又测试了1000次，后边基本可以稳定在0.005(还是比较稳的)】
  
方法二：调用WIN API中的QueryPerformanceCounter
 
1、延时5us时，精度很差
 
using System;
using System.Runtime.InteropServices;
namespace ConsoleApp1
    class Program
        static void Main(string[] args)
            System.Diagnostics.Stopwatch stopTime = new System.Diagnostics.Stopwatch();
            stopTime.Start();
            for (int i = 0; i < 20; i++)
                delayUs(5);//延时即5us,0.005ms
                Console.WriteLine(stopTime.Elapsed.TotalMilliseconds);
            Console.WriteLine("测试结束");
            Console.ReadLine();
        [DllImport("kernel32.dll")]
        extern static short QueryPerformanceCounter(ref long x);
        [DllImport("kernel32.dll")]
        extern static short QueryPerformanceFrequency(ref long x);
        /// <summary>
        /// 微秒延时
        /// </summary>
        /// <param name="delay_Time">延时时间,单位:us</param>
        public static void delayUs(long delay_Time)
            long stop_Value = 0;
            long start_Value = 0;
            long freq = 0;
            long n = 0;
            QueryPerformanceFrequency(ref freq);  //获取CPU频率
            long count = delay_Time * freq / 1000000;   //这里写成1000000就是微秒，写成1000就是毫秒
            QueryPerformanceCounter(ref start_Value); //获取初始前值
            while (n < count) //不能精确判定
                QueryPerformanceCounter(ref stop_Value);//获取终止变量值
                n = stop_Value - start_Value;
运行结果【延时5us时】：
 
  
2、延时500us时，精度高些
 
500us延时下，进一步研究：
 
500us延时下，分别延时1s、2s、4s、5s、10s、20s、40s、60s、120s、240s。测试源码如下： 
using System;
using System.Runtime.InteropServices;
using System.Diagnostics;
namespace ConsoleApp1
    class Program
        static void Main(string[] args)
            Stopwatch stopTime = new Stopwatch();
            stopTime.Start();
            //【01】总用时1s
            for (int i = 0; i < 2000; i++)
                delayUs(500);//延时即5us,0.005ms
            Console.WriteLine(stopTime.Elapsed.TotalMilliseconds);
            stopTime.Stop();
            //【02】总用时2s
            stopTime = new Stopwatch();
            stopTime.Start();          
            for (int i = 0; i < 4000; i++)
                delayUs(500




    
);//延时即5us,0.005ms
            Console.WriteLine(stopTime.Elapsed.TotalMilliseconds);
            stopTime.Stop();
            //【03】总用时3s
            stopTime = new Stopwatch();
            stopTime.Start();           
            for (int i = 0; i < 6000; i++)
                delayUs(500);//延时即5us,0.005ms
            Console.WriteLine(stopTime.Elapsed.TotalMilliseconds);
            stopTime.Stop();
            //【04】总用时4s
            stopTime = new Stopwatch();
            stopTime.Start();           
            for (int i = 0; i < 8000; i++)
                delayUs(500);//延时即5us,0.005ms
            Console.WriteLine(stopTime.Elapsed.TotalMilliseconds);
            stopTime.Stop();
            //【05】总用时5s
            stopTime = new Stopwatch();
            stopTime.Start();           
            for (int i = 0; i < 10000; i++)
                delayUs(500);//延时即5us,0.005ms
            Console.WriteLine(stopTime.Elapsed.TotalMilliseconds);
            stopTime.Stop();
            //【06】总用时10s
            stopTime = new Stopwatch();
            stopTime.Start();         
            for (int i = 0; i < 20000; i++)
                delayUs(500);//延时即5us,0.005ms
            Console.WriteLine(stopTime.Elapsed.TotalMilliseconds);
            stopTime.Stop();
            //【07】总用时20s
            stopTime = new Stopwatch();
            stopTime.Start();         
            for (int i = 0; i < 40000; i++)
                delayUs(500);//延时即5us,0.005ms
            Console.WriteLine(stopTime.Elapsed.TotalMilliseconds);
            stopTime.Stop();
            //【08】总用时40s
            stopTime = new Stopwatch();
            stopTime.Start();       
            for (int i = 0; i < 80000; i++)
                delayUs(500);//延时即5us,0.005ms
            Console.WriteLine(stopTime.Elapsed.TotalMilliseconds);
            stopTime.Stop();
            //【09】总用时60s
            stopTime = new Stopwatch();
            stopTime.Start();      
            for (int i = 0; i < 120000; i++)
                delayUs(500);//延时即5us,0.005ms
            Console.WriteLine(stopTime.Elapsed.TotalMilliseconds);
            stopTime.Stop();
            //【10】总用时120s
            stopTime = new Stopwatch();
            stopTime.Start();       
            for (int i = 0; i < 240000; i++)
                delayUs(500);//延时即5us,0.005ms
            Console.WriteLine(stopTime.Elapsed.TotalMilliseconds);
            stopTime.Stop();
            Console.WriteLine("测试结束");
            Console.ReadLine();
        [DllImport("kernel32.dll")]
        extern static short QueryPerformanceCounter(ref long x);
        [DllImport("kernel32.dll")]
        extern static short QueryPerformanceFrequency(ref long x);
        /// <summary>
        /// 微秒延时
        /// </summary>
        /// <param name="delay_Time">延时时间,单位:us</param>
        public static void delayUs(long delay_Time)
            long stop_Value = 0;
            long start_Value = 0;
            long freq = 0;
            long n = 0;
            QueryPerformanceFrequency(ref freq);  //获取CPU频率
            long count = delay_Time * freq / 1000000;   //这里写成1000000就是微秒，写成1000就是毫秒
            QueryPerformanceCounter(ref start_Value); //获取初始前值
            while (n < count) //不能精确判定
                QueryPerformanceCounter(ref stop_Value);//获取终止变量值
                n = stop_Value - start_Value;
多次运行结果如下：
 
 对于测试结果1进行分析： 
 跑1min相差50000us，共120000个循环，每个循环（500us）相差0.417us（50000÷120000=0.417）
 
 跑2min相差111000us，共240000个循环，每个循环（500us）相差0.4625us（111000÷240000=0.4625）
  
结论：【500us的延时，相对来说还是很准的】
 
方法三：DateTime.Ticks【延时效果最差】
 
DateTime.Ticks：表示0001 年 1 月 1 日午夜 12:00:00 以来所经历的 100 纳秒数，即Ticks的属性为100纳秒（1Ticks = 0.0001毫秒）。 
//延时，单位：微妙us
 public static void delay(long t)
            long b = DateTime.Now.Ticks / 10;
            long e = 0; long c = 0; ;
                e = DateTime.Now.Ticks / 10;
                c = e - b;               
            while (c < t);
const parsed = μs . parse ( now )
// { microseconds: 786, milliseconds: 599, seconds: 0, minutes: 38, hours: 14, days: 16254 }
 作为一个字符串
parsed . toString ( )
// "16254 days 14 hours 38 minutes 0 seconds 599 milliseconds 786 microseco
				基于51单片机的精确延时(微秒级)对于某些对时间精度要求较高的程序，用c 写延时显得有些力不从心，故需用到汇编程序。
本人通过测试，总结了51 的精确延时函数(在c 语言中嵌入汇编)分享给大家。至于如何在c
中嵌入汇编大家可以去网上查查，这方面的资料很多，且很简单。以12MHz 晶振为例，12MHz
晶振的机器周期为1us，所以，执行一条单周期指令所用时间就是1us，如NOP 指令。下
面具体阐述一下。
C# DateTime日期格式化
DateTime.Now.Ticks
ticks这个属性值是指从0001年1月1日12：00:00开始到此时的以ticks为单位的时间，就是以ticks表示的时间的间隔数。
微秒（μs：microsecond）
纳秒（ns：nanosecond）
毫秒（ms：millionsecond）
1ticks=100纳秒=0.1微秒
1微秒=1纳秒
1毫秒=10000t
DateTime dt = new DateTime(2018, 3, 31, 2, 30, 10, 33);
//转北京时间，毫秒精确后两位
string str = dt.AddHours(8).ToString("yyyy/MM/dd h:mm:ss.ff");//2018-3-31 10:30:10.33
//转其他时间，毫秒...
				在LINQ to Entities 查询中，使用常规日期格式转换函数Convert.ToDateTime()以及日期比较函数TimeSpan.Subtract().Days，都很麻烦而且会出错:LINQ to Entities不能识别方法。。。
那么要想在LINQ to Entities 查询中，计算两个日期之间相差的天数，该怎么办呢？
别慌，.NET已经为你准备好了工具！
System.D...
				OSAL（Operating System Abstraction Layer）是一个操作系统抽象层，它的主要作用是隐藏底层操作系统的细节，提供一组标准的 API 接口，方便实现跨平台的代码。因此，在使用 OSAL 实现微秒延时时，可以使用 OSAL 提供的延时函数。
OSAL 中提供了一个 `OS_TaskDelay` 函数，可以让任务休眠指定的时间，单位是毫秒（ms）。如果需要实现微秒级别的延时，可以在任务中循环调用 `OS_TaskDelay` 函数，每次休眠一定的毫秒数，直到达到需要延时的微秒数。
例如，以下代码演示了如何使用 OSAL 实现 500 微秒的延时：
#include "osal.h"
void delay_us(uint32_t us) {
    uint32_t ms = us / 1000; // 计算需要休眠的毫秒数
    us = us % 1000; // 计算剩余的微秒数
    OS_TaskDelay(ms); // 休眠指定的毫秒数
    for (uint32_t i = 0; i < us * 1000; i++) {
        // 循环等待指定的微秒数
int main() {
    // 延时 500 微秒
    delay_us(500);
    return 0;
需要注意的是，使用循环实现微秒延时时，循环次数过多可能会导致 CPU 占用率过高，因此需要谨慎使用。如果需要更高精度的延时，可以考虑使用硬件定时器或其他专用的延时模块。