💻 🌲 🧚🏻 .NET में दिलचस्प छंटनी व्यवहार 👩🏾‍⚖️ 😗 🕊️

यह सब इस तथ्य के साथ शुरू हुआ कि परीक्षण एक सहयोगी के काम पर पड़ने लगे। और केवल उसके पास एक है। मैं विवरण में नहीं गया, लेकिन मुद्दा यह है कि परीक्षण में दो सूची ऑब्जेक्ट थे। पहला संदर्भ था, और दूसरा परीक्षण विधि द्वारा लौटाया गया था। तब शीटों की तुलना तत्व द्वारा तत्व से की गई थी।
परीक्षण क्रैश का कारण जल्दी से पता चला: एक सहयोगी के लिए, परिणामी सरणी में तत्वों का क्रम संदर्भ सरणी में क्रम का उल्टा था। परीक्षण विधि के कोड में, हमने अपने तुलनित्र के साथ मानक List.Sort का उपयोग किया, जो हमेशा 0. वापस आता है। यह इस परीक्षण पर था कि तत्व पूरी टीम के लिए एक ही क्रम में वापस आए, और एक कर्मचारी के लिए बिल्कुल विपरीत। यह जल्दी से पता चला कि सहकर्मी को लंबे समय से कोई अपडेट नहीं था और mscorlib.dll के संस्करण में वह दूसरों की तुलना में बहुत अलग था। इस पर कोई भी शांत हो सकता है, लेकिन यह मेरे लिए दिलचस्प हो गया, मैंने आगे खुदाई करने का फैसला किया और यही मुझे पता चला।
छँटाई के बाद और समान तत्वों के साथ शीट की सामग्री भिन्न हो सकती है, क्योंकि एमएसडीएन के अनुसार, लिस्टसॉर्ट क्विकॉर्ट का उपयोग करता है, जो कि हम सभी जानते हैं, अस्थिर है। हालांकि, एक दिलचस्प विशेषता है। उसके बारे में आगे।

यह कोड लें:

कोड

using System; using System.Collections.Generic; namespace fkComparer { internal struct Smth { public int X; public int Y; } internal class SmthComparer : IComparer<Smth> { #region Implementation of IComparer<in smth> public int Compare(Smth x, Smth y) { Result.Count++; if(xY < yY) return -1; if(xY > yY) return 1; return 0; } #endregion } internal static class Result { public static int Count; } internal class Program { static void Main() { List<Smth> list = new List<Smth> {new Smth {X = 4, Y = 4}, new Smth {X = 5, Y = 4}, new Smth {X = 6, Y = 4}}; SmthComparer comparrer = new SmthComparer(); for (int i = 0; i < aaa.Count; i++) { Console.WriteLine(list[i].X); } Console.WriteLine("***************"); aaa.Sort(comparrer); Console.WriteLine(Result.Count); Console.WriteLine("***************"); for(int i = 0; i < aaa.Count; i++) { Console.WriteLine(list[i].X); } Console.ReadLine(); } } }

सिद्धांत रूप में, कुछ खास नहीं। एक स्मथ संरचना है जिसमें दो क्षेत्र हैं। इस संरचना के लिए एक तुलनित्र है। हम शीट को तुलनित्र के समान तीन संरचनाओं के साथ संतृप्त करते हैं, सॉर्ट करने से पहले शीट की सामग्री प्रदर्शित करते हैं, फिर सॉर्ट करते हैं, फिर जो तुलना की गई थी उसकी संख्या प्रदर्शित करते हैं, फिर सॉर्ट करने के बाद शीट की सामग्री प्रदर्शित करते हैं।
अब देखते हैं कि .NET फ्रेमवर्क के तीन अलग-अलग संस्करण क्या हैं।

.NET ढाँचा 4.0 संस्करण mscorlib.dll 4.0.30319.17929 का

4
5
6
***************
3
***************
4
5
6

.NET फ्रेमवर्क 4.0 संस्करण mscorlib.dll 4.0.30319.18047

4
5
6
***************
7
***************
6
5
4

.NET फ्रेमवर्क 4.5

4
5
6
***************
3
***************
4
5
6

जैसा कि आप देख सकते हैं। .NET के पुराने संस्करण में, छँटाई स्थिर है और केवल तीन तुलनाएँ की जाती हैं। .NET 4.0 के नवीनतम संस्करण में, छँटाई अस्थिर है और सात (!) तुलना की जाती है। .NET 4.5 में, छंटनी फिर से मजबूत है और 3 तुलना फिर से की जाती है।
यानी .NET 4.0 का नया संस्करण समान तत्वों को धीमा करता है। इसकी पुष्टि करने के लिए, मैंने समान तत्वों की संख्या को 100 तक बढ़ाया और .NET 4.0 - 813 तुलना के नवीनतम संस्करण में प्राप्त किया, और पुराने संस्करण के .NET 4.0 में और .NET 4.5 - 390 में।
इस प्रकार, यह पता चला है कि Microsoft ने सब कुछ सही किया, फिर गलत, फिर सही। इसके अलावा, यह समस्या कहीं न कहीं एक ओलंपियाड के रूप में मेरे पास आ सकती है।

ZY: मैंने अपनी खुद की सरलतम तुलनात्मक संख्या की गणना के साथ त्वरित छंटनी लिखी:

कोड

  static void Sort(int left, int right) { int l = left; int r = right; Smth m = list[left + (right - left) / 2]; while(true) { Result.Count++; while(list[l].Y < mY) { l++; Result.Count++; } Result.Count++; while(list[r].Y > mY) { r--; Result.Count++; } if(l < r) { Smth t = list[l]; list[l] = list[r]; list[r] = t; l++; r--; } if(l >= r) break; } if(left < r) Sort(left, r); if(right > l) Sort(l, right); }

और यहां तक कि उसने विश्वासघात किया कि केवल 744 तुलनाएं थीं। .NET 4.0 के नवीनतम संस्करण के लिए तुलनात्मक कॉल से कम है

.NET में दिलचस्प छंटनी व्यवहार

More articles: