blocks|key|1705072|text|使用秒表类。在msdn上有一个很好的例子：http://msdn.microsoft.com/en-us/library/system.diagnostics.stopwatch.aspx|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1705073|++++Stopwatch+stopWatch+=+Stopwatch.StartNew();
++++Thread.Sleep(10000);
++++stopWatch.Stop();
++++//+Get+the+elapsed+time+as+a+TimeSpan+value.
++++TimeSpan+ts+=+stopWatch.Elapsed;|code-block|syntax|javascript|1705074|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.diagnostics.stopwatch.aspx^0|L|21|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Use Stopwatch class. There is a decent example on msdn: <a href="http://msdn.microsoft.com/en-us/library/system.diagnostics.stopwatch.aspx" rel="noreferrer">http://msdn.microsoft.com/en-us/library/system.diagnostics.stopwatch.aspx</a>

<pre><code> Stopwatch stopWatch = Stopwatch.StartNew();
 Thread.Sleep(10000);
 stopWatch.Stop();
 // Get the elapsed time as a TimeSpan value.
 TimeSpan ts = stopWatch.Elapsed;
</code></pre>

blocks|key|1705078|text|您可能需要System.Diagnostics.StopWatch。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1705079|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.diagnostics.stopwatch.aspx^0|5|S|5|S|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

You probably want <a href="http://msdn.microsoft.com/en-us/library/system.diagnostics.stopwatch.aspx" rel="noreferrer"><code>System.Diagnostics.StopWatch</code></a>.

blocks|key|1705344|text|如果您正在寻找Environment.TickCount的功能，但又没有创建新Stopwatch对象的开销，则可以使用静态Stopwatch.GetTimestamp()方法(以及Stopwatch.Frequency)来计算较长的时间跨度。因为GetTimestamp()返回一个long，所以它在很长一段时间内都不会溢出(在我用来写这篇文章的机器上，超过100,000年)。它也比Environment.TickCount更精确，后者的最大分辨率为10到16毫秒。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1705345|entityMap^0|7|L|13|9|1P|O|2I|J|3F|E|3X|4|5C|L|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|G|$]]

If you're looking for the functionality of <code>Environment.TickCount</code> but without the overhead of creating new <code>Stopwatch</code> objects, you can use the static <code>Stopwatch.GetTimestamp()</code> method (along with <code>Stopwatch.Frequency</code>) to calculate long time spans. Because <code>GetTimestamp()</code> returns a <code>long</code>, it won't overflow for a very, very long time (over 100,000 years, on the machine I'm using to write this). It's also much more accurate than <code>Environment.TickCount</code> which has a maximum resolution of 10 to 16 milliseconds.

blocks|key|1705407|text|Environment.TickCount似乎比其他解决方案要快得多：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1705408|Environment.TickCount+71
DateTime.UtcNow.Ticks+213
sw.ElapsedMilliseconds+1273|code-block|syntax|javascript|1705409|测量结果是由以下代码生成的：|1705410|static+void+Main(+string[]+args+)+{
++++const+int+max+=+10000000;
++++//
++++//
++++for+(+int+j+=+0;+j+<+3;+j%2B%2B+)+{
++++++++var+sw+=+new+Stopwatch();
++++++++sw.Start();
++++++++for+(+int+i+=+0;+i+<+max;+i%2B%2B+)+{
++++++++++++var+a+=+Environment.TickCount;
++++++++}
++++++++sw.Stop();
++++++++Console.WriteLine(+$"Environment.TickCount+{sw.ElapsedMilliseconds}"+);
++++++++//
++++++++//
++++++++sw+=+new+Stopwatch();
++++++++sw.Start();
++++++++for+(+int+i+=+0;+i+<+max;+i%2B%2B+)+{
++++++++++++var+a+=+DateTime.UtcNow.Ticks;
++++++++}
++++++++sw.Stop();
++++++++Console.WriteLine(+$"DateTime.UtcNow.Ticks+{sw.ElapsedMilliseconds}"+);
++++++++//
++++++++//
++++++++sw+=+new+Stopwatch();
++++++++sw.Start();
++++++++for+(+int+i+=+0;+i+<+max;+i%2B%2B+)+{
++++++++++++var+a+=+sw.ElapsedMilliseconds;
++++++++}
++++++++sw.Stop();
++++++++Console.WriteLine(+$"sw.ElapsedMilliseconds+{sw.ElapsedMilliseconds}"+);
++++}
++++Console.WriteLine(+"Done"+);
++++Console.ReadKey();
}|1705411|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Environment.TickCount seems to be much faster then the other solutions:

<pre><code>Environment.TickCount 71
DateTime.UtcNow.Ticks 213
sw.ElapsedMilliseconds 1273
</code></pre>

The measurements were generated by the following code:

<pre><code>static void Main( string[] args ) {
 const int max = 10000000;
 //
 //
 for ( int j = 0; j &lt; 3; j++ ) {
 var sw = new Stopwatch();
 sw.Start();
 for ( int i = 0; i &lt; max; i++ ) {
 var a = Environment.TickCount;
 }
 sw.Stop();
 Console.WriteLine( $"Environment.TickCount {sw.ElapsedMilliseconds}" );
 //
 //
 sw = new Stopwatch();
 sw.Start();
 for ( int i = 0; i &lt; max; i++ ) {
 var a = DateTime.UtcNow.Ticks;
 }
 sw.Stop();
 Console.WriteLine( $"DateTime.UtcNow.Ticks {sw.ElapsedMilliseconds}" );
 //
 //
 sw = new Stopwatch();
 sw.Start();
 for ( int i = 0; i &lt; max; i++ ) {
 var a = sw.ElapsedMilliseconds;
 }
 sw.Stop();
 Console.WriteLine( $"sw.ElapsedMilliseconds {sw.ElapsedMilliseconds}" );
 }
 Console.WriteLine( "Done" );
 Console.ReadKey();
}
</code></pre>

blocks|key|1705124|text|使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1705125|System.Diagnostics.Stopwatch|code-block|syntax|javascript|1705126|它有一个名为|1705127|EllapsedMilliseconds|1705128|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Use 

<pre><code>System.Diagnostics.Stopwatch
</code></pre>

It has a property called

<pre><code>EllapsedMilliseconds
</code></pre>

blocks|key|1490119|text|您应该改用Stopwatch类。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1490120|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/28637/is-datetimenow-the-best-way-to-measure-a-functions-performance^0|5|9|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

You should use the <a href="https://stackoverflow.com/questions/28637/is-datetimenow-the-best-way-to-measure-a-functions-performance">Stopwatch</a> class instead.

blocks|key|1490166|text|我本想说把它打包成秒表类，但Grzenio已经说对了，所以我会给他一个提振。这样的封装决定了哪种方式更好，这种情况可能会随着时间的推移而改变。我记得在一些系统上花费时间是多么的昂贵，所以有一个可以实现最好的技术的地方是非常重要的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1490167|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I was going to say wrap it into a stopwatch class, but Grzenio already said the right thing, so I will give him an uptick. Such encapsulation factors out the decision as to which way is better, and this can change in time. I remember being shocked at how expensive it can be getting the time on some systems, so having one place that can implement the best technique can be very important.

blocks|key|1490226|text|对于一次性计时，它甚至更容易编写|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1490227|Stopwatch+stopWatch+=+Stopwatch.StartNew();
...dostuff...
Debug.WriteLine(String.Format("It+took+{0}+milliseconds",
++++++++++++++++++++++++++++++stopWatch.EllapsedMilliseconds)));|code-block|syntax|javascript|1490228|考虑到ElapsedTicks字段是一个很长的字段，我猜TickCount中不太可能出现的回绕对StopWatch来说甚至不是什么问题。在我的机器上，StopWatch是高分辨率的，每秒2.4e9次。即使以这样的速度，也需要超过121年的时间才能使ticks字段溢出。当然，我不知道在被子下面发生了什么，所以对此持保留态度。然而，我注意到StopWatch的文档甚至没有提到环绕问题，而TickCount的文档却提到了。|1490229|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

For one-shot timing, it's even simpler to write

<pre><code>Stopwatch stopWatch = Stopwatch.StartNew();
...dostuff...
Debug.WriteLine(String.Format("It took {0} milliseconds",
 stopWatch.EllapsedMilliseconds)));
</code></pre>

I'd guess the cosmically unlikely wraparound in TickCount is even less of a concern for StopWatch, given that the ElapsedTicks field is a long. On my machine, StopWatch is high resolution, at 2.4e9 ticks per second. Even at that rate, it would take over 121 years to overflow the ticks field. Of course, I don't know what's going on under the covers, so take that with a grain of salt. However, I notice that the documentation for StopWatch doesn't even mention the wraparound issue, while the doc for TickCount does.

blocks|key|1490395|text|溢出补偿|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1490396|如前所述，翻转可能发生在24.9天之后，或者，如果您使用uint+cast，则可能发生在49.8天之后。因为我不想pInvoke+GetTickCount64，所以我写了这个溢出补偿。示例代码使用'byte‘来保持数字的便捷性。请看一看，里面可能还是有错误：|1490397|using+System;
namespace+ConsoleApp1+{
++++class+Program+{
++++++++//
++++++++static+byte+Lower+=+byte.MaxValue+/+3;
++++++++static+byte+Upper+=+2+*+byte.MaxValue+/+3;
++++++++//
++++++++///<summary>Compute+delta+between+two+TickCount+values+reliably,+because+TickCount+might+wrap+after+49.8+days.</summary>
++++++++static+short+Delta(+byte+next,+byte+ticks+)+{
++++++++++++if+(+next+<+Lower+)+{
++++++++++++++++if+(+ticks+>+Upper+)+{
++++++++++++++++++++return+(short)+(+ticks+-+(+byte.MaxValue+%2B+1+%2B+next+)+);
++++++++++++++++}
++++++++++++}
++++++++++++if+(+next+>+Upper+)+{
++++++++++++++++if+(+ticks+<+Lower+)+{
++++++++++++++++++++return+(short)+(+(+ticks+%2B+byte.MaxValue+%2B+1+)+-+next+);
++++++++++++++++}
++++++++++++}
++++++++++++return+(short)+(+ticks+-+next+);
++++++++}
++++++++//
++++++++static+void+Main(+string[]+args+)+{
++++++++++++//+Init
++++++++++++Random+rnd+=+new+Random();
++++++++++++int+max+=+0;
++++++++++++byte+last+=+0;
++++++++++++byte+wait+=+3;
++++++++++++byte+next+=+(byte)+(+last+%2B+wait+);
++++++++++++byte+step+=+0;
++++++++++++//+Loop+tick
++++++++++++for+(+byte+tick+=+0;+true;+)+{
++++++++++++++++//
++++++++++++++++short+delta+=+Delta(+next,+tick+);
++++++++++++++++if+(+delta+>=+0+)+{
++++++++++++++++++++Console.WriteLine(+"RUN:+last:+{0}+next:+{1}+tick:+{2}+delta:+{3}",+last,+next,+tick,+delta+);
++++++++++++++++++++last+=+tick;
++++++++++++++++++++next+=+(byte)+(+last+%2B+wait+);
++++++++++++++++}
++++++++++++++++//+Will+overflow+to+0+automatically
++++++++++++++++step+=+(byte)+rnd.Next(+0,+11+);
++++++++++++++++tick+%2B=+step;
++++++++++++++++max%2B%2B;+if+(+max+>+99999+)+break;
++++++++++++}
++++++++}
++++}
}|code-block|syntax|javascript|1490398|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<h2>Overflow compensation</h2>
As said before, rollover may happen after 24.9 days, or, if you use an uint cast, after 49.8 days.
Because I did not want to pInvoke GetTickCount64, I wrote this overflow compensation. The sample code is using 'byte' to keep the numbers handy. Please have a look at it, it still might contain errors:
<pre><code>using System;
namespace ConsoleApp1 {
 class Program {
 //
 static byte Lower = byte.MaxValue / 3;
 static byte Upper = 2 * byte.MaxValue / 3;
 //
 ///&lt;summary&gt;Compute delta between two TickCount values reliably, because TickCount might wrap after 49.8 days.&lt;/summary&gt;
 static short Delta( byte next, byte ticks ) {
 if ( next &lt; Lower ) {
 if ( ticks &gt; Upper ) {
 return (short) ( ticks - ( byte.MaxValue + 1 + next ) );
 }
 }
 if ( next &gt; Upper ) {
 if ( ticks &lt; Lower ) {
 return (short) ( ( ticks + byte.MaxValue + 1 ) - next );
 }
 }
 return (short) ( ticks - next );
 }
 //
 static void Main( string[] args ) {
 // Init
 Random rnd = new Random();
 int max = 0;
 byte last = 0;
 byte wait = 3;
 byte next = (byte) ( last + wait );
 byte step = 0;
 // Loop tick
 for ( byte tick = 0; true; ) {
 //
 short delta = Delta( next, tick );
 if ( delta &gt;= 0 ) {
 Console.WriteLine( &quot;RUN: last: {0} next: {1} tick: {2} delta: {3}&quot;, last, next, tick, delta );
 last = tick;
 next = (byte) ( last + wait );
 }
 // Will overflow to 0 automatically
 step = (byte) rnd.Next( 0, 11 );
 tick += step;
 max++; if ( max &gt; 99999 ) break;
 }
 }
 }
}
</code></pre>

blocks|key|1705510|text|TickCount64|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1705511|在这个新函数上做了一些快速测试，我发现(优化，发布64位，1000mio循环)：|1705512|Environment.TickCount:+2265
Environment.TickCount64:+2531
DateTime.UtcNow.Ticks:+69016|code-block|syntax|javascript|1705513|未优化代码的测量结果也是类似的。测试代码：|1705514|static+void+Main(+string[]+args+)+{
++++long+start,+end,+length+=+1000+*+1000+*+1000;
++++start+=+Environment.TickCount64;
++++for+(+int+i+=+0;+i+<+length;+i%2B%2B+)+{
++++++++var+a+=+Environment.TickCount;
++++}
++++end+=+Environment.TickCount64;
++++Console.WriteLine(+"Environment.TickCount:+{0}",+end+-+start+);
++++start+=+Environment.TickCount64;
++++for+(+int+i+=+0;+i+<+length;+i%2B%2B+)+{
++++++++var+a+=+Environment.TickCount64;
++++}
++++end+=+Environment.TickCount64;
++++Console.WriteLine(+"Environment.TickCount64:+{0}",+end+-+start+);
++++start+=+Environment.TickCount64;
++++for+(+int+i+=+0;+i+<+length;+i%2B%2B+)+{
++++++++var+a+=+DateTime.UtcNow.Ticks;
++++}
++++end+=+Environment.TickCount64;
++++Console.WriteLine(+"DateTime.UtcNow.Ticks:+{0}",+end+-+start+);
}|1705515|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

<h2>TickCount64</h2>
Doing some quick measurements on this new function, I found (optimized, release 64-bit, 1000mio loops):
<pre><code>Environment.TickCount: 2265
Environment.TickCount64: 2531
DateTime.UtcNow.Ticks: 69016
</code></pre>
The measurements for not-optimized code were similar.
Test code:
<pre><code>static void Main( string[] args ) {
 long start, end, length = 1000 * 1000 * 1000;
 start = Environment.TickCount64;
 for ( int i = 0; i &lt; length; i++ ) {
 var a = Environment.TickCount;
 }
 end = Environment.TickCount64;
 Console.WriteLine( &quot;Environment.TickCount: {0}&quot;, end - start );
 start = Environment.TickCount64;
 for ( int i = 0; i &lt; length; i++ ) {
 var a = Environment.TickCount64;
 }
 end = Environment.TickCount64;
 Console.WriteLine( &quot;Environment.TickCount64: {0}&quot;, end - start );
 start = Environment.TickCount64;
 for ( int i = 0; i &lt; length; i++ ) {
 var a = DateTime.UtcNow.Ticks;
 }
 end = Environment.TickCount64;
 Console.WriteLine( &quot;DateTime.UtcNow.Ticks: {0}&quot;, end - start );
}
</code></pre>

Is it ever OK to use <code>Environment.TickCount</code>to calculate time spans?

<pre><code>int start = Environment.TickCount;
// Do stuff
int duration = Environment.TickCount - start;
Console.WriteLine("That took " + duration " ms");
</code></pre>

Because <code>TickCount</code> is signed and will rollover after 25 days (it takes 50 days to hit all 32 bits, but you have to scrap the signed bit if you want to make any sense of the math), it seems like it's too risky to be useful. 

I'm using <code>DateTime.Now</code> instead. Is this the best way to do this?

<pre><code>DateTime start = DateTime.Now;
// Do stuff
TimeSpan duration = DateTime.Now - start;
Console.WriteLine("That took " + duration.TotalMilliseconds + " ms");
</code></pre>

Environment.TickCount vs DateTime.Now

是否可以使用Environment.TickCount来计算时间跨度？int start = Environment.TickCount;// Do stuffint duration = Environment.TickCount - start;Console.WriteLine("That took " + duration " ms");因为TickCount是带符号的，并将在25天后滚动

问Environment.TickCount vs DateTime.Now
EN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Environment.TickCount vs DateTime.NowEN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Environment.TickCount vs DateTime.Now
EN