C#更加精准的时钟

using System;
using System.ComponentModel;
using System.Runtime.InteropServices;

namespace SKII.SKIITimer
{
    /// <summary>
    /// 相差2，3毫秒
    /// </summary>
    public sealed class MillisecondTimer : IComponent, IDisposable
    {
        private static TimerCaps caps;
        private int interval;
        private bool isRunning;
        private int resolution;
        private TimerCallback timerCallback;
        private int timerID;

        public int Interval
        {
            get
            {
                return this.interval;
            }
            set
            {
                if ((value < caps.periodMin) || (value > caps.periodMax))
                {
                    throw new Exception("超出计时范围！");
                }
                this.interval = value;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public bool IsRunning
        {
            get
            {
                return this.isRunning;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public ISite Site
        {
            set;
            get;
        }

        public event EventHandler Disposed;  // 这个事件实现了IComponet接口
        public event EventHandler Tick;

        static MillisecondTimer()
        {
            timeGetDevCaps(ref caps, Marshal.SizeOf(caps));
        }

        public MillisecondTimer()
        {
            this.interval = caps.periodMin;    // 
            this.resolution = caps.periodMin;  //

            this.isRunning = false;
            this.timerCallback = new TimerCallback(this.TimerEventCallback);

        }

        public MillisecondTimer(IContainer container)
            : this()
        {
            container.Add(this);
        }

        ~MillisecondTimer()
        {
            timeKillEvent(this.timerID);
        }

        public void Start()
        {
            if (!this.isRunning)
            {
                this.timerID = timeSetEvent(this.interval, this.resolution, this.timerCallback, 0, 1); // 间隔性地运行

                if (this.timerID == 0)
                {
                    throw new Exception("无法启动计时器");
                }
                this.isRunning = true;
            }
        }

        public void Stop()
        {
            if (this.isRunning)
            {
                timeKillEvent(this.timerID);
                this.isRunning = false;
            }
        }

        /// <summary>
        /// 实现IDisposable接口
        /// </summary>
        public void Dispose()
        {
            timeKillEvent(this.timerID);
            GC.SuppressFinalize(this);
            EventHandler disposed = this.Disposed;
            if (disposed != null)
            {
                disposed(this, EventArgs.Empty);
            }
        }

        //***************************************************  内部函数  ******************************************************************
        [DllImport("winmm.dll")]
        private static extern int timeSetEvent(int delay, int resolution, TimerCallback callback, int user, int mode);


        [DllImport("winmm.dll")]
        private static extern int timeKillEvent(int id);


        [DllImport("winmm.dll")]
        private static extern int timeGetDevCaps(ref TimerCaps caps, int sizeOfTimerCaps);
        //  The timeGetDevCaps function queries the timer device to determine its resolution. 



        private void TimerEventCallback(int id, int msg, int user, int param1, int param2)
        {
            if (this.Tick != null)
            {
                this.Tick(this, null);  // 引发事件
            }
        }

        //***************************************************  内部类型  ******************************************************************

        private delegate void TimerCallback(int id, int msg, int user, int param1, int param2); // timeSetEvent所对应的回调函数的签名


        /// <summary>
        /// 定时器的分辨率（resolution）。单位是ms，毫秒
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
        private struct TimerCaps
        {
            public int periodMin;
            public int periodMax;
        }
    }
}

        private void sysTimer_Tick(object sender, EventArgs e)
        {
            for (int i = 0; i < 1000; i++)
            {

            }
            //需要定时执行的内容
            this.Invoke((EventHandler)delegate
            {
                txtShow.Text += "时间：" + stopwatch.ElapsedMilliseconds.ToString() + "\r\n";

            });

        }

        private void btnSKIITimer_Click(object sender, EventArgs e)
        {
            stopwatch.Start();
            txtShow.Text += "时间1：" + stopwatch.ElapsedMilliseconds.ToString() + "\r\n";
            delay(1000);
            txtShow.Text += "时间2：" + stopwatch.ElapsedMilliseconds.ToString() + "\r\n";
            delay(1000);
            txtShow.Text += "时间3：" + stopwatch.ElapsedMilliseconds.ToString() + "\r\n";
            delay(1000);
            txtShow.Text += "时间4：" + stopwatch.ElapsedMilliseconds.ToString() + "\r\n";
            delay(1000);
            txtShow.Text += "时间5：" + stopwatch.ElapsedMilliseconds.ToString() + "\r\n";
            stopwatch.Stop();

            if (sysTimer.IsRunning)
            {
                sysTimer.Stop();
                stopwatch.Stop();
                btnSKIITimer.Text = "开始";
            }
            else
            {
                sysTimer.Start();
                stopwatch.Start();
                btnSKIITimer.Text = "停止";
            }
        }

        //调用API函数
        [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"></param>
        public void delay(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 / 1000;
            QueryPerformanceCounter(ref start_Value); //获取初始前值

            while (n < count) //不能精确判定
            {
                QueryPerformanceCounter(ref stop_Value);//获取终止变量值
                n = stop_Value - start_Value;
            }
        }

//定义
        private MillisecondTimer sysTimer;
        Stopwatch stopwatch = new Stopwatch();
//初始化
            sysTimer = new MillisecondTimer();
            sysTimer.Tick += sysTimer_Tick;
            sysTimer.Interval = 100; //每秒执行