एंथनी पेगम ने इसे सर्वश्रेष्ठ कहा है। इस काम के लिए सही उपकरण का उपयोग करें। मैं ऐसा इसलिए कहता हूं क्योंकि प्रदर्शन के समय Distinct या HashSet इतना बड़ा नहीं है। संग्रह को HashSet का उपयोग करें जब संग्रह हमेशा अलग-अलग सामानों को रखना चाहिए। यह प्रोग्रामर को यह भी बताता है कि आप इसमें डुप्लिकेट जोड़ नहीं सकते हैं। एक सामान्य List<T> और .Distinct() का उपयोग करें जब आपको डुप्लीकेट जोड़ना होगा और बाद में डुप्लीकेट हटा देना होगा। इरादा मायने रखता है।
सामान्य तौर पर,
एक) एक HashSet अगर आप डाटाबेस से नई वस्तुओं जोड़ रहे हैं और आप अपने स्वयं की एक कस्टम Equals निर्दिष्ट नहीं किया है किसी भी अच्छे कार्य न करें। डीबी से प्रत्येक ऑब्जेक्ट आपके हैशसेट के लिए एक नया उदाहरण हो सकता है (यदि आप केवल नए हैं) और इससे संग्रह में डुप्लीकेट हो जाएंगे। उस मामले में सामान्य List<T> का उपयोग करें।
बी) यदि आपके पास हैशसेट के लिए परिभाषित समानता तुलनाकर्ता है, और आपके संग्रह को हमेशा केवल विशिष्ट वस्तुओं को रखना चाहिए, हैशसेट का उपयोग करना चाहिए।
सी) यदि आपके पास हैशसेट के लिए एक समानता तुलनाकर्ता परिभाषित है, और आप डीबी से केवल विशिष्ट वस्तुएं चाहते हैं लेकिन संग्रह को हमेशा केवल अलग-अलग ऑब्जेक्ट्स (यानी बाद में जोड़े जाने वाले डुप्लीकेट्स) को पकड़ने की आवश्यकता नहीं होती है, तो एक तेज़ तरीका प्राप्त करना है डीबी से एक हैशसेट तक आइटम और उसके बाद उस हैशसेट से नियमित सूची लौटाएं।
डी) सबसे अच्छी बात यह है कि आपको डेटाबेस में डुप्लीकेट हटाने का कार्य देना है, सही उपकरण और यह पहली कक्षा है!
प्रदर्शन के अंतर के रूप में, मेरे परीक्षण में मुझे हमेशा हैशसेट तेजी से पाया जाता है, लेकिन फिर यह केवल मामूली है। यह स्पष्ट रूप से सूची दृष्टिकोण के साथ विचार कर रहा है जिसे आपको पहले जोड़ना है और फिर उस पर एक विशिष्ट कार्य करना है।
टेस्ट विधि: दो सामान्य कार्यों के साथ शुरू,
public static void Benchmark(Action method, int iterations = 10000)
{
Stopwatch sw = new Stopwatch();
sw.Start();
for (int i = 0; i < iterations; i++)
method();
sw.Stop();
MsgBox.ShowDialog(sw.Elapsed.TotalMilliseconds.ToString());
}
public static List<T> Repeat<T>(this ICollection<T> lst, int count)
{
if (count < 0)
throw new ArgumentOutOfRangeException("count");
var ret = Enumerable.Empty<T>();
for (var i = 0; i < count; i++)
ret = ret.Concat(lst);
return ret.ToList();
}
कार्यान्वयन:
var d = Enumerable.Range(1, 100).ToList().Repeat(100);
HashSet<int> hash = new HashSet<int>();
Benchmark(() =>
{
hash.Clear();
foreach (var item in d)
{
hash.Add(item);
}
});
~ 3300 एमएस
var d = Enumerable.Range(1, 100).ToList().Repeat(100);
List<int> list = new List<int>();
Benchmark(() =>
{
list.Clear();
foreach (var item in d)
{
list.Add(item);
}
list = list.Distinct().ToList();
});
~ 5800 एमएस
2,5 सेकंड के एक अंतर 10000 वस्तुओं की एक सूची के लिए बुरा नहीं है जब एक और 10000 बार दोहराया। सामान्य मामलों के लिए अंतर शायद ही ध्यान देने योग्य होगा।
सबसे अच्छा अपने वर्तमान डिजाइन के साथ आप के लिए संभवतः दृष्टिकोण:
var d = Enumerable.Range(1, 100).ToList().Repeat(100);
HashSet<int> hash = new HashSet<int>();
List<int> list = new List<int>();
Benchmark(() =>
{
hash.Clear();
foreach (var item in d)
{
hash.Add(item);
}
list = hash.ToList();
});
~ 3300 एमएस
कोई महत्वपूर्ण अंतर नहीं है, देखते हैं ..
आंशिक असंबंधित - इस उत्तर को पोस्ट करने के बाद, मुझे यह जानकर उत्सुकता थी कि इसमें सबसे अच्छा तरीका क्या है एक सामान्य सूची से डुप्लिकेट को हटा रहा है।
var d = Enumerable.Range(1, 100).ToList().Repeat(100);
HashSet<int> hash = new HashSet<int>();
List<int> list = new List<int>();
Benchmark(() =>
{
hash = new HashSet<int>(d);
});
~ 3900 एमएस
var d = Enumerable.Range(1, 100).ToList().Repeat(100);
List<int> list = new List<int>();
Benchmark(() =>
{
list = d.Distinct().ToList();
});
~ 3200 एमएस
यहाँ सही उपकरण Distinct hackish HashSet की तुलना में तेजी है! शायद यह हैश सेट बनाने का ओवरहेड है।
मैंने संदर्भ सूची जैसे विभिन्न अन्य संयोजनों के साथ परीक्षण किया है, मूल सूची में डुप्लीकेट के बिना आदि परिणाम लगातार हैं।
+1 केवल उचित उत्तर के लिए! – nawfal