getTime
public long getTime()
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。

返回： 自 1970 年 1 月 1 日 00:00:00 GMT 以来此日期表示的毫秒数。

.net DateTime.Ticks

public long Ticks {get;}
   
 属性值

此属性的值为自 0001 年 1 月 1 日午夜 12:00 以来所经过时间以 100 毫微秒为间隔表示时的数字。

好了一个返回的是毫秒一个返回的是微秒，所以知道毫秒与微妙之间的转化也是有必要的

1秒=1000毫秒(ms) 1毫秒=1/1,000秒(s)
1秒=1,000,000 微秒(μs) 1微秒=1/1,000,000秒(s)
1秒=1,000,000,000 纳秒(ns)
1纳秒=1/1,000,000,000秒(s)
1秒=1,000,000,000,000 皮秒(ps)

Console.WriteLine(DateTime.Now.Ticks); // 输出：633603924670937500

也就是说，从0001 年 1 月 1 日午夜 12:00:00 以来到现在已经过了  633603924670937500 * 10^-7 秒。

1. using System;  
2. using System.Collections.Generic;  
3.   
4. class Sentence  
5. {  
6.   static void Main()  
7.   {  
8.     long ticks0 = DateTime.Now.Ticks;  
9.     for (int i = 0; i < int.MaxValue; i++)  
10.     {  
11.       // ...  
12.     }  
13.     long ticks1 = DateTime.Now.Ticks;  
14.     long n = (ticks1 - ticks0) * 100;  
15.     Console.WriteLine("上面这段程序运行了{0}毫微秒", n);  
16.   }  
17. }  

1. using System;  
2. using System.Collections.Generic;  
3.   
4. class Sentence  
5. {  
6.   static void Main()  
7.   {  
8.     long ticks0 = DateTime.Now.Ticks;  
9.     for (int i = 0; i < int.MaxValue; i++)  
10.     {  
11.       // ...  
12.     }  
13.     long ticks1 = DateTime.Now.Ticks;  
14.     double n = (ticks1 - ticks0) / 10000000.0;  
15.     Console.WriteLine("上面这段程序运行了{0}秒", n);  
16.   }  
17. }  

1. using System;  
2. using System.Runtime.InteropServices;  
3. public class A  
4. {  
5.     [DllImport("kernel32.dll")]  
6.     static extern bool QueryPerformanceCounter([In, Out] ref long lpPerformanceCount);  
7.     [DllImport("kernel32.dll")]  
8.     static extern bool QueryPerformanceFrequency([In, Out] ref long lpFrequency);  
9.   
10.     static long _f = 0;  
11.   
12.     static public long GetTickCount()  
13.     {  
14.         long f = _f;  
15.   
16.         if (f == 0)  
17.         {  
18.             if (QueryPerformanceFrequency(ref f))  
19.             {  
20.                 _f = f;  
21.             }  
22.             else  
23.             {  
24.                 _f = -1;  
25.             }  
26.         }  
27.         if (f == -1)  
28.         {  
29.             return Environment.TickCount * 10000;  
30.         }  
31.         long c = 0;  
32.         QueryPerformanceCounter(ref c);  
33.         return (long)(((double)c) * 1000 * 10000 / ((double)f));  
34.     }  
35.   
36.     //GetTickCount()为0时的DateTime.Ticks值  
37.     static long _tc = 0;  
38.   
39.     //这个返回的不是真正的精确时间，但时间与时间的差是精确的。  
40.     //GetExactNow与DateTime.Now的偏差比DateTime.Now的精度还要小，所以该偏差  
41.     static public DateTime GetExactNow()  
42.     {  
43.         if (_tc == 0)  
44.         {  
45.             long tc = GetTickCount();  
46.             DateTime dt = DateTime.Now;  
47.             _tc = dt.Ticks - tc;  
48.             return dt;  
49.         }  
50.   
51.         return new DateTime(_tc + GetTickCount());  
52.     }  
53. }  

1秒   =   1000   毫秒
        =   1000000   微秒
        =   1000000000   毫微秒
        =   1000000000   纳秒
        =   1000000000000   皮秒

1s   =   1000   ms
      =   1000000   us
      =   1000000000   ns
      =   1000000000000   ps

1(秒)=10的9次方(毫微秒)

<!--End_rbody_41637559//-->