एक संग्रह LINQ

Question

मैं इस तरह एक संग्रह है में प्रकार के आधार पर,

Class Base{} 
Class A : Base {} 
Class B : Base {} 

List<Base> collection = new List<Base>(); 
collection.Add(new A()); 
collection.Add(new B()); 
collection.Add(new A()); 
collection.Add(new A()); 
collection.Add(new B()); 

अब मैं प्रकार (ए/बी) पर आधारित संग्रह क्रमबद्ध करना चाहते हैं सॉर्ट करने के लिए कैसे। मैं यह कैसे कर सकता हूं? क्रिप्या मेरि सहायता करे।

Answer 1

आप प्रकार का उपयोग कर सकते हैं

वैकल्पिक रूप से, अगर आप इस तरह एक डाटा-संरचना में 'समूह' रख सकते हैं सूचना स्वयं:

collection.Sort((a,b) => 
    { 
     bool aType = a.GetType() == typeof(A); 
     bool bType = b.GetType() == typeof(A); 
     return aType.CompareTo(bType); 
    }); 

यह आपके द्वारा निर्दिष्ट दो प्रकार के लिए काम करेगा, लेकिन उनके आगे स्केल नहीं करता है। यह आपको स्पष्ट रूप से आदेश निर्दिष्ट करने की अनुमति देता है (यानी: यदि आप "ए" से पहले तत्वों को "बी" चाहते हैं, तो आप इसे इस तकनीक का उपयोग करके काम कर सकते हैं)।

आप कई प्रकार का समर्थन करने की जरूरत है, और आदेश आप की तरह कुछ कर सकता है पहले से निर्दिष्ट करने की जरूरत नहीं है, तो: एक सी:

collection.Sort((a,b) => a.GetType().FullName.CompareTo(b.GetType().FullName)); 

यह प्रकार की कोई भी संख्या (यानी संभाल होगा और एक डी उप प्रकार भी), और उन्हें अपने पूर्ण प्रकार के नाम से आदेश दें।

Answer 2

संपादित करें: मैं इस बारे में सोच रहा है कि आप क्या चाहते:

आप 'जगह से बाहर' छंटाई और सूची फिर नियत कोई आपत्ति नहीं है, तो यह काम करना चाहिए:

collection = collection.GroupBy(item => item.GetType()) 
         .SelectMany(g => g) 
         .ToList(); 

या पर निर्भर करता है आपके जरूरतों, जैसे कुछ:

collection = collection.OrderBy(item => item.GetType().FullName) 
         .ToList(); 

उस में जगह होना चाहिए, तो एक कस्टम comparer लेखन और list.Sort शायद सबसे अच्छा विकल्प है।

---

समूह प्रकार से आइटम करने के लिए

, आप GroupBy उपयोग कर सकते हैं:

var groupedItems = collection.GroupBy(item => item.GetType()); 

यह आस्थगित निष्पादन का उपयोग करता है।

var itemsByTypeLookUp = collection.ToLookup(item => item.GetType()); 

foreach(A a in itemsByTypeLookUp[typeof(A)]) 
{ 
    ... 
} 

आप केवल एक निश्चित प्रकार के लिए देख रहे हैं:

var itemsOfTypeA = collection.OfType<A>(); 

Answer 3

collection.Where(entry => entry is A).Concat(collection.Where(entry => entry is B)) 

तुम क्या आवश्यकता है करता है?

Answer 4

यह ऑर्डर करने जा रहा है ताकि A दूसरा और B दूसरा होगा।

var xx = list.OrderBy(x => x.GetType() == typeof(B)).ToList(); 

यह निम्न सांत्वना परियोजना की पुष्टि करता है:

class Program 
{ 
    public class X { } 
    public class A : X { } 
    public class B : X { } 
    static void Main() 
    { 
     List<X> list = new List<X>(); 
     list.Add(new B()); 
     list.Add(new A()); 
     list.Add(new B()); 
     list.Add(new A()); 
     list.Add(new A()); 

     // A.GetType() == typeof(B) will be "0" making the type A go first 
     // B.GetType() == typeof(B) will be "1" making the type B go last 
     var xx = list.OrderBy(x => x.GetType() == typeof(B)).ToList(); 

     Console.ReadLine(); 
    } 
} 

इस मामले में मैं यह सोचते हैं रहा हूँ आप केवल A और B है। यदि आपके पास अधिक प्रकार हैं तो आपको प्रत्येक प्रकार के मान को वापस करने के लिए एक तुलनाकर्ता बनाना होगा।आपके पास बेस क्लास पर एक संपत्ति भी हो सकती है जो तत्वों का क्रम सेट करेगी, फिर आप इस संपत्ति के साथ सूची को सॉर्ट कर सकते हैं।

Answer 5

private static int OrderOnType(Base item) 
{ 
    if(item is A) 
    return 0; 
    if(item is B) 
    return 1; 
    return 2; 
} 

फिर से अपने पिकअप ले:

collection.OrderBy(OrderOnType) 

या

collection.Sort((x, y) => OrderOnType(x).CompareTo(OrderOnType(y))); 

कि क्या आप में जगह छँटाई या नहीं करना चाहता पर निर्भर करते हुए। यदि आप वास्तव में चाहते थे तो आप ऑर्डरऑनटाइप को लैम्ब्डा में डाल सकते हैं, लेकिन यह मेरे लिए अधिक पठनीय लगता है, और जब मैं पठनीयता को कम करने के बजाय जोड़ता हूं तो मैं लैम्ब्डा को रखना पसंद करता हूं।

Answer 6

collection.OrderBy(i => i.GetType() == typeof(A) ? 0 : 1); 

आप सभी A के साथ एक दृश्य देंगे तो सभी B रों

Answer 7

कुछ इस तरह मेरे लिए काम करता है।

collection.OrderBy(p => p.GetType().Equals(typeof(B))).ThenBy(p => p.GetType().Equals(typeof(A))).ToList(); 

मेरे कोड:

class Employer; 
class Doctor : Employer 
class Administrator : Employer 
class Nurse : Employer 
List<Employer> collection = new List<Employer>(); 
collection.Add(new Doctor()); 
collection.Add(new Administrator()); 
collection.Add(new Doctor()); 
collection.Add(new Nurse()); 
collection.Add(new Administrator()); 
collection = collection.OrderBy(p => p.GetType().Equals(typeof(Nurse))).ThenBy(p => p.GetType().Equals(typeof(Doctor))).ThenBy(p => p.GetType().Equals(typeof(Administrator))).ToList();