वहाँ नहीं था, है और नहीं भी हो सकता है, कम से कम मुझे तो विश्वास होगा। संग्रह समानता के पीछे का कारण संभवतः एक उपयोगकर्ता परिभाषित व्यवहार है।
संग्रह में तत्वों को एक विशेष क्रम में नहीं माना जाता है, हालांकि उनके पास स्वाभाविक रूप से एक आदेश है, यह नहीं है कि तुलनात्मक एल्गोरिदम पर क्या भरोसा करना चाहिए। कहो कि आपके पास दो संग्रह हैं:
{1, 2, 3, 4}
{4, 3, 2, 1}
वे समान हैं या नहीं? तुम्हें पता होना चाहिए, लेकिन मुझे नहीं पता कि तुम्हारी बात क्या है।
जब तक एल्गोरिदम सॉर्टिंग नियम प्रदान नहीं करते, तब तक संग्रह डिफ़ॉल्ट रूप से अनियंत्रित होते हैं। एसक्यूएल सर्वर आपके ध्यान में लाएगा, जब आप पेजिंग करने की कोशिश कर रहे हैं, तो इसके लिए आपको सॉर्टिंग नियम प्रदान करने होंगे:
https://docs.microsoft.com/en-US/sql/t-sql/queries/select-order-by-clause-transact-sql?view=sql-server-2017
फिर भी एक और दो संग्रह:
{1, 2, 3, 4}
{1, 1, 1, 2, 2, 3, 4}
फिर से, वे समान हैं या नहीं? आप ही बताओ ..
किसी संग्रह की तत्व पुनरावृत्ति विभिन्न परिदृश्यों में अपनी भूमिका निभाती है और कुछ संग्रह जैसे Dictionary<TKey, TValue>दोहराए गए तत्वों की अनुमति भी नहीं देते हैं।
मेरा मानना है कि इस प्रकार की समानता अनुप्रयोग परिभाषित है और रूपरेखा इसलिए संभव कार्यान्वयन के सभी प्रदान नहीं किया है।
वैसे, सामान्य मामलों Enumerable.SequenceEqualमें यह काफी अच्छा है, लेकिन यह निम्नलिखित मामले में गलत है:
var a = new Dictionary<String, int> { { "2", 2 }, { "1", 1 }, };
var b = new Dictionary<String, int> { { "1", 1 }, { "2", 2 }, };
Debug.Print("{0}", a.SequenceEqual(b)); // false
मैं इस तरह के सवालों के कुछ जवाब पढ़ता हूं (आप उनके लिए गूगल कर सकते हैं) और सामान्य तौर पर मैं क्या उपयोग करूंगा:
public static class CollectionExtensions {
public static bool Represents<T>(this IEnumerable<T> first, IEnumerable<T> second) {
if(object.ReferenceEquals(first, second)) {
return true;
}
if(first is IOrderedEnumerable<T> && second is IOrderedEnumerable<T>) {
return Enumerable.SequenceEqual(first, second);
}
if(first is ICollection<T> && second is ICollection<T>) {
if(first.Count()!=second.Count()) {
return false;
}
}
first=first.OrderBy(x => x.GetHashCode());
second=second.OrderBy(x => x.GetHashCode());
return CollectionExtensions.Represents(first, second);
}
}
इसका मतलब है कि एक संग्रह मूल तत्वों को ध्यान में रखे बिना दोहराए गए समय सहित उनके तत्वों में दूसरे का प्रतिनिधित्व करता है। कार्यान्वयन के कुछ नोट:
GetHashCode()सिर्फ आदेश के लिए है समानता के लिए नहीं; मुझे लगता है कि इस मामले में यह पर्याप्त है
Count() वास्तव में संग्रह की गणना नहीं करेगा और सीधे संपत्ति के कार्यान्वयन में गिर जाएगा ICollection<T>.Count
यदि संदर्भ समान हैं, तो यह सिर्फ बोरिस है
IList? प्रश्न अस्पष्ट है।