🧑🏽‍🤝‍🧑🏻 🤨 ✋🏽 foreach या इसके लिए सवाल है 🕘 💔 💞

/ Foreach लूप चुनने का सवाल दुनिया जितना पुराना है। हम सभी ने सुना है कि foreach की तुलना में धीमी है। लेकिन हर कोई नहीं जानता कि क्यों ... लेकिन क्या वास्तव में ऐसा है?

जब मैंने .NET सीखना शुरू किया, तो एक व्यक्ति ने मुझे बताया कि foreach किसी औचित्य के बिना, की तुलना में 2 गुना धीमा काम करता है, और मैंने इसे लिया। अब, जब किसी के शब्द मेरे लिए पर्याप्त नहीं हैं, तो मैंने इस लेख को लिखने का फैसला किया।

इस लेख में, मैं चक्रों के प्रदर्शन का पता लगाता हूं, साथ ही कुछ बारीकियों को भी स्पष्ट करता हूं।

तो चलिए!

निम्नलिखित कोड पर विचार करें:

foreach (var item in Enumerable.Range(0, 128)) { Console.WriteLine(item); }

फॉर्च्यूप लूप वाक्य-रचना चीनी है, और इस मामले में, कंपाइलर इसे निम्न कोड में भेजता है:

 IEnumerator<int> enumerator = Enumerable.Range(0, 128).GetEnumerator(); try { while (enumerator.MoveNext()) { int item = enumerator.Current; Console.WriteLine(item); } } finally { if (enumerator != null) { enumerator.Dispose(); } }

यह जानकर, कोई भी आसानी से मान सकता है कि फॉरचेट को धीमा क्यों होना चाहिए-ए के लिए। जब foreach का उपयोग करते हैं:

एक नई वस्तु बनाई गई है - एक पुनरावृत्त;
प्रत्येक पुनरावृत्ति पर, MoveNext विधि कहा जाता है;
प्रत्येक पुनरावृत्ति पर, करंट प्रॉपर्टी एक्सेस की जाती है, जो एक मेथड कॉल के बराबर है;

वह सब है! हालांकि नहीं, सब कुछ इतना सरल नहीं है ...

वहाँ एक और अति सूक्ष्म अंतर है! सौभाग्य से या, दुर्भाग्य से, सी # / सीएलआर में अनुकूलन का एक गुच्छा है। सौभाग्य से, क्योंकि कोड तेज है, दुर्भाग्य से, क्योंकि डेवलपर्स को इसके बारे में जानना है (फिर भी, मैं इसे सौभाग्य से, और अधिक बदलाव के रूप में मानता हूं)।

उदाहरण के लिए, चूंकि सरणियाँ सीएलआर में अत्यधिक रूप से एकीकृत हैं, इसलिए उनके लिए बड़ी संख्या में अनुकूलन हैं। उनमें से एक फ़ॉरच लूप की चिंता करता है।

इस प्रकार, एक चलने योग्य इकाई फ़ॉरच लूप के प्रदर्शन का एक महत्वपूर्ण पहलू है, क्योंकि इसे इसके आधार पर विभिन्न तरीकों से तैनात किया जा सकता है।

लेख में हम एररेटिंग एरे और लिस्ट पर विचार करेंगे। For-a और foreach-a के अलावा, हम स्थैतिक विधि Array.ForEach के साथ-साथ List.ForEach का एक उदाहरण का उपयोग करके पुनरावृत्ति पर भी विचार करेंगे।

परीक्षण विधियों

 static double ArrayForWithoutOptimization(int[] array) { int sum = 0; var watch = Stopwatch.StartNew(); for (int i = 0; i < array.Length; i++) sum += array[i]; watch.Stop(); return watch.Elapsed.TotalMilliseconds; } static double ArrayForWithOptimization(int[] array) { int length = array.Length; int sum = 0; var watch = Stopwatch.StartNew(); for (int i = 0; i < length; i++) sum += array[i]; watch.Stop(); return watch.Elapsed.TotalMilliseconds; } static double ArrayForeach(int[] array) { int sum = 0; var watch = Stopwatch.StartNew(); foreach (var item in array) sum += item; watch.Stop(); return watch.Elapsed.TotalMilliseconds; } static double ArrayForEach(int[] array) { int sum = 0; var watch = Stopwatch.StartNew(); Array.ForEach(array, i => { sum += i; }); watch.Stop(); return watch.Elapsed.TotalMilliseconds; }

रिलीज कोड के साथ अनुकूलित ध्वज के साथ परीक्षण किए गए थे। सरणी और सूची में तत्वों की संख्या 100,000,000 है। परीक्षण मशीन में एक इंटेल कोर i-5 प्रोसेसर है और इसके बोर्ड पर 8 जीबी रैम है।

सरणियों

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

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

Array.ForEach विधि ने सबसे खराब परिणाम दिखाया। इसका कार्यान्वयन काफी सरल दिखता है:

 public static void ForEach<T>(T[] array, Action<T> action) { for (int index = 0; index < array.Length; ++index) action(array[index]); }

फिर यह इतनी धीमी गति से क्यों काम करता है? सब के बाद, पर्दे के पीछे, वह हमेशा के लिए उपयोग करता है। यह सब कार्रवाई प्रतिनिधि को बुलाने के बारे में है। वास्तव में, प्रत्येक पुनरावृत्ति में एक विधि कहा जाता है, और हम जानते हैं कि यह एक अतिरिक्त उपरि है। इसके अलावा, जैसा कि आप जानते हैं, प्रतिनिधियों को जल्दी से नहीं बुलाया जाता है जैसा हम चाहते हैं, इसलिए परिणाम।

सरणियों के साथ, सब कुछ स्पष्ट किया गया था। सूचियों पर जाएं।

सूचियों के लिए, हम समान तुलना विधियों का उपयोग करेंगे।

सूचियों

यहाँ एक पूरी तरह से अलग परिणाम है !!!

जब सूचियों पर पुनरावृत्ति होती है, तो / foreach लूप अलग-अलग परिणाम देते हैं। तथ्य यह है कि यहां कोई अनुकूलन नहीं है, और फ़ॉरचैट इट्रेटर बनाने और इसके साथ आगे काम करने में बदल रहा है।

सबसे अच्छा परिणाम सूची की लंबाई कैशिंग के लिए अपेक्षित के रूप में दिखाया गया है। सूची अनुक्रमण JIT इनलाइन के बाद से प्रदर्शन को प्रभावित नहीं करता है (अनुक्रमण एक पैरामीटर के साथ एक सामान्य संपत्ति है)।

foreach ने परिणाम की तुलना में लगभग 2.5 गुना धीमा दिखाया। यह इसकी जटिल संरचना के कारण है, जो पर्दे के पीछे काम करता है (कॉलनक्नेक्स्ट, करंट)।

List.ForEach के साथ-साथ Array.ForEach ने सबसे खराब परिणाम दिखाया। तथ्य यह है कि जेआईटी इनलाइन नहीं हैं-यह आभासी तरीके हैं, और प्रतिनिधि, जैसा कि आप जानते हैं, हमेशा वस्तुतः आह्वान किया जाता है।

इस पद्धति का कार्यान्वयन इस तरह दिखता है:

 public void ForEach(Action<T> action) { int num = this._version; for (int index = 0; index < this._size && num == this._version; ++index) action(this._items[index]); if (num == this._version) return; ThrowHelper.ThrowInvalidOperationException(ExceptionResource.InvalidOperation_EnumFailedVersion); }

यहां, प्रत्येक पुनरावृत्ति पर, कार्रवाई प्रतिनिधि को बुलाया जाता है। प्रत्येक बार यह भी जांचा जाता है कि क्या सूची पुनरावृत्ति के दौरान बदल गई है, और यदि यह है, तो एक अपवाद फेंक दिया गया है।

एक दिलचस्प तथ्य यह है कि सरणियों के लिए, ForEach पद्धति स्थिर है, जबकि सूचियों के लिए यह उदाहरण है। मुझे लगता है कि यह उत्पादकता बढ़ाने के लिए किया जाता है। जैसा कि आप जानते हैं, सूची एक नियमित सरणी पर आधारित है, और इसलिए, ForEach पद्धति इंडेक्स द्वारा सरणी को संदर्भित करती है, जो कि अनुक्रमणिका के माध्यम से सूचकांक तक पहुंचने की तुलना में कई गुना तेज है।

वीआर लिस्ट्स को अरेज करता है

विशिष्ट संख्या

लूप के लिए (लंबाई कैशिंग के बिना) और सरणियों के लिए फ़ॉर्च लंबाई कैशिंग के साथ सी की तुलना में थोड़ी तेज़ी से काम करते हैं;
Array.ForEach लूप के लिए / foreach छोरों की तुलना में लगभग छह गुना धीमा है;
सूचियों पर (लंबाई कैशिंग के बिना) सरणियों की तुलना में लगभग 3 गुना धीमी गति से काम करता है;
सूचियों पर (लंबाई कैशिंग के साथ) सरणियों की तुलना में लगभग 2 गुना धीमा काम करता है;
सूचियों पर फॉर्चूनन लगभग 6 बार सरणियों पर फॉर्च की तुलना में धीमा है;

पुरस्कार विजेताओं

सरणियों में:

सूचियों में:

निष्कर्ष में

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

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

पढ़ने के लिए धन्यवाद।

foreach या इसके लिए सवाल है