C# 版本的 計時器類：精確到微秒 秒后保留一位小數 支持年月日時分秒帶單位的輸出

class TimeCount
    {
        // 臨時變量，存放當前類能表示的最大年份值
        private static ulong MaxYear = 0;

        
        /// <summary>
        /// 獲取毫秒能表示的最大年份數
        /// </summary>
        /// <returns>年份數最大值</returns>
        public static ulong GetMaxYearCount()
        {
            if (TimeCount.MaxYear != 0)
                return TimeCount.MaxYear;
            else
            {
                double ulongMax = Math.Pow(2, 64);
                double yearToMiliseconds = (double)12 * (double)30 * (double)24 * (double)3600 * (double)1000;
                TimeCount.MaxYear = (ulong)(ulongMax / yearToMiliseconds);
                return TimeCount.MaxYear;
            }
        }

        /// <summary>
        /// 把當前系統時間轉換成毫秒
        /// </summary>
        /// <returns>當前系統時間所對應的毫秒數</returns>
        public static ulong GetCurrentTimeByMiliSec()
        {
            DateTime t = DateTime.Now;
            ulong millisecond = ((((((ulong)t.Year * 12 + (ulong)t.Month) * 30 + (ulong)t.Day) * 24 + (ulong)t.Hour) * 60 + (ulong)t.Minute) * 60 
                  + (ulong)t.Second) * 1000 + (ulong)(t.Millisecond);
            return millisecond;
        }

        /// <summary>
        /// 不太實用的函數，給定三個輸入，得到時間差，以字符串形式返回
        /// </summary>
        /// <param name="str">時間前面的前綴，例如“繪制XX所用時間為：”</param>
        /// <param name="a">第一個時間</param>
        /// <param name="b">第二個時間，無所謂先后，總之最后會取絕對值</param>
        /// <returns></returns>
        public static string GetTimeInterval(string str, ulong a, ulong b)
        {
            ulong interval = b - a;
            str += Convert.ToString(Math.Abs(( ((double)interval)/1000)));
            str += "秒";
            return str;
        }

        /// <summary>
        /// 得到兩個給定時間（毫秒）之間的時間差，最終值會去絕對值
        /// </summary>
        /// <param name="a">早一些的時間（毫秒）</param>
        /// <param name="b">晚一些的時間（毫秒）</param>
        /// <returns></returns>
        public static double GetTimeInterValBySec(ulong a, ulong b)
        {
            return Math.Abs(((double)b - (double)a)/(double)1000);
        }

        /// <summary>
        /// 小數點后保留一位小數
        /// </summary>
        /// <param name="double1">一個小數</param>
        /// <returns>一個字符串</returns>
        public static string RemainOneFigureAfterDot(double double1)
        {
            string tempStr = double1.ToString();
            string double1str;
            if (tempStr == "")
            {
                return "0.0";
            }
            int index = tempStr.IndexOf(".");
            if (index == -1)
            {
                double1str = tempStr + ".0";
                return double1str; 
            }
            else
            {
                if (tempStr.Length < index + 2)
                    return tempStr + ".0";
                else
                {
                    double1str = tempStr.Substring(0, index + 2);
                    return double1str; 
                }
            }
        }


        /// <summary>
        /// 年月日時分化成秒
        /// </summary>
        public enum YMDHmS
        {
             yearSc = 365 * 24 * 3600,
             monSc = 30 * 24 * 3600,
             daySc = 24 * 3600,
             houSc = 3600,
             minSc = 60
        }


        /// <summary>
        /// 把一個String格式的以秒為單位的時間，轉化成年月日時分秒為單位的時間字符串，並最后的秒保留一位小數
        /// </summary>
        /// <param name="seconds">秒數，string格式</param>
        /// <returns></returns>
        public static string SecondsToYYMMDDhhmmss(string seconds)
        {
            double secondsDble = Convert.ToDouble(seconds);
            return TimeCount.SecondsToYYMMDDhhmmss(secondsDble);
        }

        /// <summary>
        /// 把一個int格式的以秒為單位的時間，轉化成年月日時分秒為單位的時間字符串，並最后的秒保留一位小數
        /// </summary>
        /// <param name="seconds">秒數，int格式</param>
        /// <returns></returns>
        public static string SecondsToYYMMDDhhmmss(int seconds)
        {
            double secondsDble = Convert.ToDouble(seconds);
            return TimeCount.SecondsToYYMMDDhhmmss(secondsDble);
        }

        /// <summary>
        /// 把一個ulong格式的以秒為單位的時間，轉化成年月日時分秒為單位的時間字符串，並最后的秒保留一位小數
        /// </summary>
        /// <param name="seconds">秒數，ulong格式</param>
        /// <returns></returns>
        public static string SecondsToYYMMDDhhmmss(ulong seconds)
        {
            double secondsDble = Convert.ToDouble(seconds);
            return TimeCount.SecondsToYYMMDDhhmmss(secondsDble);
        }


        /// <summary>
        /// 把一個double格式的以秒為單位的時間，轉化成年月日時分秒為單位的時間字符串，並最后的秒保留一位小數
        /// </summary>
        /// <param name="secondsDble">秒數，double格式</param>
        /// <returns></returns>
        public static string SecondsToYYMMDDhhmmss(double secondsDble)
        {
            string returnSTR = "";
            if (secondsDble == 0)
            {
                return "0.0秒";
            }
            int YY = 0, MM = 0, DD = 0, HH = 0, mm = 0;
            if (secondsDble >= (uint)YMDHmS.yearSc)//年
            {
                while (secondsDble > 0)
                {
                    secondsDble -= (uint)YMDHmS.yearSc;
                    YY++;
                }
                secondsDble += (uint)YMDHmS.yearSc;
                YY--;
            }
            if (secondsDble >= (uint)YMDHmS.monSc)//月
            {
                while (secondsDble > 0)
                {
                    secondsDble -= (uint)YMDHmS.monSc;
                    MM++;
                }
                secondsDble += (uint)YMDHmS.monSc;
                MM--;
            }
            if (secondsDble >= (uint)YMDHmS.daySc)//日
            {
                while (secondsDble > 0)
                {
                    secondsDble -= (uint)YMDHmS.daySc;
                    DD++;
                }
                secondsDble += (uint)YMDHmS.daySc;
                DD--;
            }
            if (secondsDble >= (uint)YMDHmS.houSc)//時
            {
                while (secondsDble > 0)
                {
                    secondsDble -= (uint)YMDHmS.houSc;
                    HH++;
                }
                secondsDble += (uint)YMDHmS.houSc;
                HH--;
            }
            if (secondsDble >= (uint)YMDHmS.minSc)//分
            {
                while (secondsDble > 0)
                {
                    secondsDble -= (uint)YMDHmS.minSc;
                    mm++;
                }
                secondsDble += (uint)YMDHmS.minSc;
                mm--;
            }
            if (YY != 0)
                returnSTR += YY.ToString() + "年";
            if (MM != 0)
                returnSTR += MM.ToString() + "月";
            if (DD != 0)
                returnSTR += DD.ToString() + "天";
            if (HH != 0)
                returnSTR += HH.ToString() + "小時";
            if (mm != 0)
                returnSTR += mm.ToString() + "分";
            if (secondsDble < 10)
            {
                returnSTR += "0" + TimeCount.RemainOneFigureAfterDot(secondsDble) + "秒";
            }
            else
            {
                returnSTR += TimeCount.RemainOneFigureAfterDot(secondsDble) + "秒";
            }
            return returnSTR;
        }
        
    }

 原文鏈接：C# 版本的 計時器類 精確到微秒 秒后保留一位小數 支持年月日時分秒帶單位的輸出