दिलचस्प पोस्ट
अगर सूची में कोई संदेह है आकार का एक्स (x + +) एक्स क्यों नहीं बढ़ाता? कस्टम तस्वीर के साथ फेसबुक एपीआई पोस्ट लिंक _GET में URL पैरामीटर का अधिकतम आकार iTextsharp का उपयोग कर पीडीएफ फाइल में पाठ या शब्द को कैसे उजागर करना है? किसी साझा फ़ाइल (यूएनसी) से एक रिमोट, गैर-विश्वसनीय डोमेन से क्रेडेंशियल के साथ एक MySQL क्वेरी का उपयोग करके संपूर्ण तालिका में टेक्स्ट को ढूंढें और बदलें Matplotlib: विभिन्न रंगों के साथ कई डिस्कनेक्ट किए गए लाइन खंडों को प्लॉट करते हुए लूप करते समय आप कैसे विभिन्न वैरिएबल नाम बनाते हैं? (अजगर) जैक्सन JSON Deserialization के साथ रूट एलिमेंट एक एकल अक्षर स्ट्रिंग के रूप में टेक्स्ट फ़ाइल आयात करें Android में हमारे अपने श्रोता इंटरफ़ेस कैसे बनायें? पायथन में एक ज्ञात संख्या में तत्वों की सूची शुरू करना पंक्ति मूल्यों को टी-एसक्यूएल में जोड़ना किसी गतिविधि का पृष्ठभूमि का रंग सफेद प्रोग्राम के रूप में कैसे सेट करें?

पर्यावरण.टिककाउंट बनाम दिनांकटाइम.अब

क्या यह कभी भी Environment.TickCount का उपयोग करने के लिए ठीक है। टाइमकैंस समय सीमा का पता लगाने के लिए?

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

चूंकि TickCount पर हस्ताक्षर किए गए हैं और 25 दिनों के बाद रोलओवर (सभी 32 बिट्स को हिट करने में 50 दिन लगते हैं, लेकिन यदि आप गणित के किसी भी प्रकार का भाव बनाना चाहते हैं तो आपको हस्ताक्षरित बिट को स्क्रैप करना होगा), ऐसा लगता है कि यह उपयोगी हो ।

मैं DateTime.Now का उपयोग कर रहा DateTime.Now बजाय क्या यह करने का सबसे अच्छा तरीका है?

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

वेब के समाधान से एकत्रित समाधान "पर्यावरण.टिककाउंट बनाम दिनांकटाइम.अब"

स्टॉपवॉच वर्ग का उपयोग करें एमएसडीएन पर एक सभ्य उदाहरण है: http://msdn.microsoft.com/en-us/library/system.diagnostics.stopwatch.aspx

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

पर्यावरण। टिकटिक गेटटिककाउंट () पर आधारित है WinAPI फ़ंक्शन। यह मिलीसेकंड में है लेकिन इसकी वास्तविक सटीकता लगभग 15.6 एमएस है तो आप कम समय अंतराल को माप नहीं सकते (या आपको 0 मिलेगा)

नोट: लौटा मूल्य इन्टर32 है, इसलिए यह काउंटर प्रत्येक ~ 49.7 दिनों पर रोल करता है। आपको इस तरह के लंबे अंतराल को मापने के लिए इसका उपयोग नहीं करना चाहिए।

DateTime.Ticks GetSystemTimeAsFileTime () WinAPI फ़ंक्शन पर आधारित है। यह 100 एस नैनोसेकंड (माइक्रोस्कोप का दसवां अंश) में है। तिथि समय की वास्तविक सटीकता सिस्टम पर निर्भर करती है। एक्सपी पर, सिस्टम घड़ी की वृद्धि लगभग 15.6 एमएस है, जो कि पर्यावरण के समान है। टिकटिक विंडोज 7 में इसकी सटीकता 1 एमएस है (जबकि एनवाइरमेंमट। टिककॉंट्स का अभी भी 15.6 एमएस है), हालांकि अगर किसी विद्युत बचत योजना का उपयोग किया जाता है (आमतौर पर लैपटॉप पर) तो यह 15.6 एमएस तक नीचे जा सकता है।

स्टॉपवॉच QueryPerformanceCounter () WinAPI फ़ंक्शन पर आधारित है (लेकिन अगर उच्च-रिज़ॉल्यूशन प्रदर्शन काउंटर आपके सिस्टम द्वारा समर्थित नहीं है, तो DateTime.Ticks उपयोग किया जाता है)

StopWatch का उपयोग करने से पहले दो समस्याएं नोट करें:

  • यह बहुप्रोसेसर सिस्टम पर अविश्वसनीय हो सकता है (देखें एमएस kb895980 , kb896256 )
  • यह अविश्वसनीय हो सकता है अगर सीपीयू आवृत्ति भिन्न होती है ( इस लेख को पढ़ें)

आप साधारण परीक्षण के साथ आपके सिस्टम पर सटीकता का मूल्यांकन कर सकते हैं:

 static void Main(string[] args) { int xcnt = 0; long xdelta, xstart; xstart = DateTime.UtcNow.Ticks; do { xdelta = DateTime.UtcNow.Ticks - xstart; xcnt++; } while (xdelta == 0); Console.WriteLine("DateTime:\t{0} ms, in {1} cycles", xdelta / (10000.0), xcnt); int ycnt = 0, ystart; long ydelta; ystart = Environment.TickCount; do { ydelta = Environment.TickCount - ystart; ycnt++; } while (ydelta == 0); Console.WriteLine("Environment:\t{0} ms, in {1} cycles ", ydelta, ycnt); Stopwatch sw = new Stopwatch(); int zcnt = 0; long zstart, zdelta; sw.Start(); zstart = sw.ElapsedTicks; // This minimizes the difference (opposed to just using 0) do { zdelta = sw.ElapsedTicks - zstart; zcnt++; } while (zdelta == 0); sw.Stop(); Console.WriteLine("StopWatch:\t{0} ms, in {1} cycles", (zdelta * 1000.0) / Stopwatch.Frequency, zcnt); Console.ReadKey(); } 

आप रोलओवर के बारे में चिंतित क्यों हैं? जब तक आप मापन कर रहे हैं वह अवधि 24.9 दिनों से कम है और आप सापेक्ष अवधि की गणना करते हैं, आप ठीक हैं। इससे कोई फर्क नहीं पड़ता कि सिस्टम चल रहा है कितनी देर तक, जब तक आप केवल उस चलने वाले समय के अपने हिस्से के साथ ही चिंता करते हैं (जैसे कि शुरू और अंत बिंदुओं पर तुलना की तुलना में कम-से-कम या अधिक से अधिक प्रदर्शन करने का विरोध) यानी यह:

  int before_rollover = Int32.MaxValue - 5; int after_rollover = Int32.MinValue + 7; int duration = after_rollover - before_rollover; Console.WriteLine("before_rollover: " + before_rollover.ToString()); Console.WriteLine("after_rollover: " + after_rollover.ToString()); Console.WriteLine("duration: " + duration.ToString()); 

सही प्रिंट:

  before_rollover: 2147483642 after_rollover: -2147483641 duration: 13 

आपको साइन बिट के बारे में चिंता करने की ज़रूरत नहीं है C #, जैसे सी, CPU को यह संभाल देता है

यह एक सामान्य स्थिति है जिसे मैंने एम्बेडेड सिस्टम में समय के साथ गिना है। मैं पहले कभी भी तुलना नहीं कर सकता <asrollover सीधे, उदाहरण के लिए। मैं हमेशा उस अवधि को खोजने के लिए घटाव का प्रदर्शन करता हूं जो रोलओवर को ध्यान में रखता है, और फिर अवधि पर किसी अन्य गणना का आधार।

आप शायद System.Diagnostics.StopWatch चाहते हैं। System.Diagnostics.StopWatchSystem.Diagnostics.StopWatch

यदि आप Environment.TickCount की कार्यक्षमता की तलाश कर रहे Environment.TickCount लेकिन नई Stopwatch ऑब्जेक्ट्स बनाने के ऊपरी हिस्से के बिना, आप लंबे Stopwatch.GetTimestamp() स्थिर Stopwatch.GetTimestamp() उपयोग कर सकते हैं। क्योंकि GetTimestamp() एक long लौटाता है, यह एक बहुत, बहुत लंबे समय (100,000 से अधिक वर्षों तक मशीन पर, मैं इसे लिखने के लिए उपयोग कर रहा हूँ) के लिए नहीं भर जाएगा। यह Environment.TickCount तुलना में अधिक सटीक Environment.TickCount जिसमें अधिकतम रिज़ॉल्यूशन 10 से 16 मिलीसेकेंड होता है

उपयोग

 System.Diagnostics.Stopwatch 

इसकी एक संपत्ति है

 EllapsedMilliseconds 

पर्यावरण.टिककाउंट बहुत तेजी से अन्य समाधानों को लगता है:

 Environment.TickCount 71 DateTime.UtcNow.Ticks 213 sw.ElapsedMilliseconds 1273 

मापन निम्न कोड द्वारा उत्पन्न किया गया था:

 static void Main( string[] args ) { const int max = 10000000; // // for ( int j = 0; j < 3; j++ ) { var sw = new Stopwatch(); sw.Start(); for ( int i = 0; i < max; i++ ) { var a = Environment.TickCount; } sw.Stop(); Console.WriteLine( $"Environment.TickCount {sw.ElapsedMilliseconds}" ); // // sw = new Stopwatch(); sw.Start(); for ( int i = 0; i < 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 < max; i++ ) { var a = sw.ElapsedMilliseconds; } sw.Stop(); Console.WriteLine( $"sw.ElapsedMilliseconds {sw.ElapsedMilliseconds}" ); } Console.WriteLine( "Done" ); Console.ReadKey(); } 

इस धागे + अतिरिक्त मानक और वेरिएंट में सबसे उपयोगी उत्तर और टिप्पणियां हो सकती हैं, इस बारे में एक अद्यतन और ताज़ा सारांश दिया गया है:

पहली बात पहले: जैसा कि अन्य लोगों ने टिप्पणियों में बताया है, चीजों ने पिछले वर्षों में "आधुनिक" विंडोज़ (Win XP ++) और .NET, और आधुनिक हार्डवेयर के साथ स्टॉपवॉच () का उपयोग नहीं करने के लिए कोई कम या कोई कारण नहीं हैं। विवरण के लिए एमएसडीएन देखें कोटेशन:

"क्या QPC सटीकता को पावर प्रबंधन या टर्बो बूस्ट तकनीक के कारण प्रोसेसर आवृत्ति परिवर्तन से प्रभावित है?
नहीं। अगर प्रोसेसर में एक अपरिवर्तनीय टीएससी है , तो क्यूपीसी इन प्रकार के परिवर्तनों से प्रभावित नहीं है। यदि प्रोसेसर में एक अपरिवर्तनीय टीएससी नहीं है, तो क्यूपीसी एक प्लेटफ़ॉर्म हार्डवेयर टाइमर पर लौट जाएगा जो प्रोसेसर आवृत्ति परिवर्तन या टर्बो बूस्ट तकनीक से प्रभावित नहीं होगा।

क्या QPC मज़बूती से बहु-प्रोसेसर सिस्टम, मल्टी-कोर सिस्टम और हाइपर-थ्रेडिंग वाले सिस्टम पर काम करता है?
हाँ

मैं कैसे तय कर सकता हूं कि QPC मेरे मशीन पर काम करता है?
आपको ऐसे चेक करने की आवश्यकता नहीं है

किस प्रोसेसर में गैर-अपरिवर्तनीय टीएससी है? [..आगे पढ़िए..] "

लेकिन अगर आपको स्टॉपवॉच () की सटीकता की आवश्यकता नहीं है या कम से कम स्टॉपवॉच (स्थिर बनाम उदाहरण-आधारित) और अन्य संभावित प्रकारों के प्रदर्शन के बारे में बिल्कुल जानना चाहते हैं, तो इसे जारी रखें:

मैंने ऊपर दिए गए बेंचमार्क को सीएससीवीजी से ऊपर ले लिया और अधिक प्रकारों के लिए कोड बढ़ाया। मैंने कुछ साल पुराने i7 4700 MQ और सी # 7 वीएस 2017 के साथ (अधिक सटीक, बाइनरी लीटरल्स के बावजूद, .NET 4.5.2 के साथ संकलित होने के साथ मापा है, यह सी # 6 है (यह प्रयोग किया जाता है: स्ट्रिंग लीटरल और 'स्टैटिक का उपयोग करके ')। विशेष रूप से स्टॉपवॉच () प्रदर्शन को बेंचमार्क के मुकाबले बेहतर लगता है।

यह एक लूप में 10 मिलियन पुनरावृत्तियों के परिणाम का एक उदाहरण है, हमेशा की तरह, निरपेक्ष मान महत्वपूर्ण नहीं हैं, लेकिन रिश्तेदार मान भी अन्य हार्डवेयर पर भिन्न हो सकते हैं:

32 बिट, अनुकूलन के बिना रिलीज मोड:

मापा गया: GetTickCount64 () [एमएस]: 275
माप: पर्यावरण। टिकटिक [एमएस]: 45
माप: दिनांक समय। यूटके अब टिक्स [एमएस]: 167
मापने वाला: स्टॉपवॉच: एलेप्सेडटिक्स [एमएस]: 277
मापा: स्टॉपवॉच: एलेप्सेड मिलिसेकंड [एमएस]: 548
मापा: स्थिर स्टॉपवॉच। GetTimestamp [एमएस]: 1 9 3
माप: स्टॉपवॉच + डेटटाइम पर रूपांतरण [एमएस]: 551
डेटटाइम के साथ तुलना करें। अब टिक्स [एमएस]: 9010

32 बिट, रिलीज मोड, अनुकूलित:

मापा गया: GetTickCount64 () [एमएस]: 1 9 8
माप: पर्यावरण। टिककंट [एमएस]: 3 9
मापा: दिनांक समय। यूटीसी अब टिक्स [एमएस]: 66 (!)
मापने वाला: स्टॉपवॉच: एलेप्सेडटिक्स [एमएस]: 175
मापा: स्टॉपवॉच: एलेप्सेड मिलिसेकंड [एमएस]: 491
मापा गया: स्थिर स्टॉपवॉच। GetTimestamp [एमएस]: 175
माप: स्टॉपवॉच + रूपांतरण तिथि समय [एमएस]: 510
डेटटाइम के साथ तुलना करें। अब टिक्स [एमएस]: 8460

64 बिट, अनुकूलन के बिना रिलीज मोड:

मापा गया: GetTickCount64 () [एमएस]: 205
माप: पर्यावरण। टिककंट [एमएस]: 3 9
माप: दिनांक समय। यूटीसी अब टिक्स [एमएस]: 127
मापने वाला: स्टॉपवॉच: एलेप्सेडटिक्स [एमएस]: 20 9
मापा: स्टॉपवॉच: एलेप्सेड मिलिसेकंड [एमएस]: 285
मापा गया: स्थिर स्टॉपवॉच। गेटटिमस्टैम्प [एमएस]: 187
माप: स्टॉपवॉच + डेटटाइम पर रूपांतरण [एमएस]: 319
डेटटाइम के साथ तुलना करें। अब टिक्स [एमएस]: 3040

64 बिट, रिलीज मोड, अनुकूलित:

मापा गया: GetTickCount64 () [एमएस]: 148
माप: पर्यावरण। टिकटिक [एमएस]: 31 (क्या यह अभी भी इसके लायक है?)
माप: दिनांकटाइम। यूटैक अब टिक्स [एमएस]: 76 (!)
मापने वाला: स्टॉपवॉच: एलेप्सेडटिक्स [एमएस]: 178
मापा: स्टॉपवॉच: एलेप्सेड मिलिसेकंड [एमएस]: 226
मापा गया: स्थिर स्टॉपवॉच। GetTimestamp [एमएस]: 175
माप: स्टॉपवॉच + डेटटाइम पर रूपांतरण [एमएस]: 246
डेटटाइम के साथ तुलना करें। अब टिक्स [एमएस]: 3020

यह बहुत ही दिलचस्प हो सकता है, कि स्टॉपवॉच समय को प्रिंट करने के लिए एक दिनांक समय मान बनाने में लगभग कोई लागत नहीं होती है व्यावहारिक तरीके से अधिक अकादमिक में दिलचस्प है कि स्थिर स्टॉपवॉच थोड़ा तेज (अपेक्षित) है। कुछ अनुकूलन बिंदु काफी दिलचस्प हैं उदाहरण के लिए, मैं यह क्यों नहीं समझा सकता कि स्टॉपवॉच। केवल 32 बिट के साथ मिलोसेकेंड बहुत ही धीमी है क्योंकि यह अन्य रूपों की तुलना में है, उदाहरण के लिए स्थिर एक यह और डेटटाइम अब 64 बिट के साथ अपनी गति को दोगुने से अधिक है।

आप देख सकते हैं: केवल लाखों फांसी के लिए, स्टॉपवॉच का समय मामला शुरू होता है। यदि यह वास्तव में मामला है (लेकिन बहुत जल्दी माइक्रो-ऑप्टिमाइज़िंग सावधान रहें), तो यह दिलचस्प हो सकता है कि GetTickCount64 () के साथ, लेकिन विशेष रूप से डेटटाइम के साथ। यूटकेनो, आपके पास स्टॉपवॉच की तुलना में कम सटीकता के साथ एक 64 बिट (लंबा) टाइमर है, लेकिन तेज़ , ताकि आपको 32 बिट "बदसूरत" पर्यावरण के साथ घूमने की ज़रूरत नहीं है। टिकटिक

जैसा कि अपेक्षित, दिनांकटाइम। अब तक सबसे धीमा है

यदि आप इसे चलाते हैं, तो कोड भी आपकी वर्तमान स्टॉपवॉच सटीकता और अधिक प्राप्त करता है।

यहां पूर्ण बेंचमार्क कोड है:

 using System.Diagnostics; using System.Runtime.InteropServices; using System.Threading; using static System.Environment; 

[…]

  [DllImport("kernel32.dll") ] public static extern UInt64 GetTickCount64(); // Retrieves a 64bit value containing ticks since system start static void Main(string[] args) { const int max = 10_000_000; const int n = 3; Stopwatch sw; // Following Process&Thread lines according to tips by Thomas Maierhofer: https://codeproject.com/KB/testing/stopwatch-measure-precise.aspx // But this somewhat contradicts to assertions by MS in: https://msdn.microsoft.com/en-us/library/windows/desktop/dn553408%28v=vs.85%29.aspx?f=255&MSPPError=-2147217396#Does_QPC_reliably_work_on_multi-processor_systems__multi-core_system__and_________systems_with_hyper-threading Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(1); // Use only the first core Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.High; Thread.CurrentThread.Priority = ThreadPriority.Highest; Thread.Sleep(2); // warmup Console.WriteLine($"Repeating measurement {n} times in loop of {max:N0}:{NewLine}"); for (int j = 0; j < n; j++) { sw = new Stopwatch(); sw.Start(); for (int i = 0; i < max; i++) { var tickCount = GetTickCount64(); } sw.Stop(); Console.WriteLine($"Measured: GetTickCount64() [ms]: {sw.ElapsedMilliseconds}"); // // sw = new Stopwatch(); sw.Start(); for (int i = 0; i < max; i++) { var tickCount = Environment.TickCount; // only int capacity, enough for a bit more than 24 days } sw.Stop(); Console.WriteLine($"Measured: Environment.TickCount [ms]: {sw.ElapsedMilliseconds}"); // // sw = new Stopwatch(); sw.Start(); for (int i = 0; i < max; i++) { var a = DateTime.UtcNow.Ticks; } sw.Stop(); Console.WriteLine($"Measured: DateTime.UtcNow.Ticks [ms]: {sw.ElapsedMilliseconds}"); // // sw = new Stopwatch(); sw.Start(); for (int i = 0; i < max; i++) { var a = sw.ElapsedMilliseconds; } sw.Stop(); Console.WriteLine($"Measured: Stopwatch: .ElapsedMilliseconds [ms]: {sw.ElapsedMilliseconds}"); // // sw = new Stopwatch(); sw.Start(); for (int i = 0; i < max; i++) { var a = Stopwatch.GetTimestamp(); } sw.Stop(); Console.WriteLine($"Measured: static Stopwatch.GetTimestamp [ms]: {sw.ElapsedMilliseconds}"); // // DateTime dt=DateTime.MinValue; // just init sw = new Stopwatch(); sw.Start(); for (int i = 0; i < max; i++) { var a = new DateTime(sw.Elapsed.Ticks); // using variable dt here seems to make nearly no difference } sw.Stop(); //Console.WriteLine($"Measured: Stopwatch+conversion to DateTime [s] with millisecs: {dt:s.fff}"); Console.WriteLine($"Measured: Stopwatch+conversion to DateTime [ms]: {sw.ElapsedMilliseconds}"); Console.WriteLine(); } // // sw = new Stopwatch(); var tickCounterStart = Environment.TickCount; sw.Start(); for (int i = 0; i < max/10; i++) { var a = DateTime.Now.Ticks; } sw.Stop(); var tickCounter = Environment.TickCount - tickCounterStart; Console.WriteLine($"Compare that with DateTime.Now.Ticks [ms]: {sw.ElapsedMilliseconds*10}"); Console.WriteLine($"{NewLine}General Stopwatch information:"); if (Stopwatch.IsHighResolution) Console.WriteLine("- Using high-resolution performance counter for Stopwatch class."); else Console.WriteLine("- Using high-resolution performance counter for Stopwatch class."); double freq = (double)Stopwatch.Frequency; double ticksPerMicroSec = freq / (1000d*1000d) ; // microsecond resolution: 1 million ticks per sec Console.WriteLine($"- Stopwatch accuracy- ticks per microsecond (1000 ms): {ticksPerMicroSec:N1}"); Console.WriteLine(" (Max. tick resolution normally is 100 nanoseconds, this is 10 ticks/microsecond.)"); DateTime maxTimeForTickCountInteger= new DateTime(Int32.MaxValue*10_000L); // tickCount means millisec -> there are 10.000 milliseconds in 100 nanoseconds, which is the tick resolution in .NET, eg used for TimeSpan Console.WriteLine($"- Approximated capacity (maxtime) of TickCount [dd:hh:mm:ss] {maxTimeForTickCountInteger:dd:HH:mm:ss}"); // this conversion from seems not really accurate, it will be between 24-25 days. Console.WriteLine($"{NewLine}Done."); while (Console.KeyAvailable) Console.ReadKey(false); Console.ReadKey(); } 

इसके बदले आपको स्टॉपवॉच कक्षा का उपयोग करना चाहिए।

मैं पर्यावरण का उपयोग करता हूं.टिककाउंट क्योंकि:

  1. स्टॉपवॉच वर्ग कॉम्पैक्ट फ्रेमवर्क में नहीं है
  2. स्टॉपवॉच टीककॉउट के रूप में एक ही अंतर्निहित टाइमिंग तंत्र का उपयोग करता है, इसलिए परिणाम अधिक या कम सटीक नहीं होंगे
  3. टिक-माउंट के साथ लपेट-आसपास की समस्या को हिट होने की संभावना नहीं है (आपको 27 दिनों के लिए अपने कंप्यूटर को चलना छोड़ना पड़ता है और फिर उस समय को मापने की कोशिश करनी चाहिए जो पल भर के पल के दौर में होती है), और यहां तक ​​कि अगर आपने किया यह परिणाम एक बड़ा नकारात्मक समय अवधि होगा मारा (तो यह तरह बाहर खड़े होंगे)।

कहा जा रहा है, मैं भी स्टॉपवॉच का उपयोग करने की सिफारिश करेगा, अगर यह आपके लिए उपलब्ध है या आप लगभग 1 मिनट ले सकते हैं और एक स्टॉपवॉच जैसी क्लास लिख सकते हैं जो पर्यावरण को लपेटते हैं.टिककाउंट

बीटीडब्लू, मैं स्टॉपवॉच प्रलेखन में कुछ भी नहीं देखता हूं जो अंतर्निहित टाइमर तंत्र के साथ लपेट-आसपास की समस्या का उल्लेख करता है, इसलिए मुझे आश्चर्य होता कि स्टॉपवॉच को उसी समस्या से ग्रस्त नहीं होता। लेकिन फिर, मैं इसके बारे में चिंतित किसी भी समय खर्च नहीं होता।

मैं कहता हूं कि इसे स्टॉपवॉच क्लास में लपेटें, लेकिन ग्रेज़ेनियो ने पहले ही कहा कि सही बात है, इसलिए मैं उसे एक uptick देगा इस प्रकार के इनकैप्सूलेशन के अनुसार निर्णय किस तरह से बेहतर है, और यह समय में बदल सकता है। मुझे याद है कि कुछ सिस्टमों पर समय कितना महंगा हो सकता है, इस पर हैरान रहना, इसलिए एक जगह होने पर कि सर्वोत्तम तकनीक लागू हो सकती है, वह बहुत महत्वपूर्ण हो सकता है

एक शॉट के लिए समय, यह लिखना भी सरल है

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

मुझे लगता है कि टिकाकाउंट में ब्रह्मांत्रिक रूप से अप्रत्याशित रूप से लपेटोराउंड स्टॉपवॉच के लिए भी कम चिंता का विषय है, बशर्ते ElapsedTicks क्षेत्र लंबा है मेरी मशीन पर, स्टॉपवॉच उच्च रिज़ॉल्यूशन, प्रति सेकंड 2.4e9 टिक पर है। उस दर पर भी, टिक्ल्स फील्ड को खत्म करने में 121 साल से अधिक समय लगेगा बेशक, मैं नहीं जानता कि कवर के नीचे क्या हो रहा है, इसलिए इसे नमक के एक अनाज के साथ ले लो। हालांकि, मैं नोटिस करता हूं कि स्टॉपवॉच के दस्तावेज में लपेटने वाले मुद्दे का भी उल्लेख नहीं किया जाता है, जबकि टिक्काउंट के लिए डॉक्टर