ऑब्जेक्ट में किसी गुण द्वारा सूची <T> कैसे सॉर्ट करें

Question

मैं एक वर्ग कहा जाता है Orderजो गुण जैसे है OrderId, OrderDate, Quantity, और Total। मेरे पास इस Orderवर्ग की एक सूची है :

List<Order> objListOrder = new List<Order>();
GetOrderList(objListOrder); // fill list of orders

अब मैं Orderऑब्जेक्ट की एक संपत्ति के आधार पर सूची को सॉर्ट करना चाहता हूं , उदाहरण के लिए मुझे ऑर्डर दिनांक या ऑर्डर आईडी द्वारा इसे सॉर्ट करने की आवश्यकता है।

मैं इसे C # में कैसे कर सकता हूं?

Comments

प्रतीक्षा करें - आप ऑर्डर दिनांक और ऑर्डर आईडी दोनों को क्रमबद्ध करना चाहते हैं ? क्योंकि अधिकांश जवाबों से लगता है कि आप केवल एक या दूसरे को छांट रहे हैं।

— गैलेक्टिक

@GalacticCowboy, @GenericTypeTea: सवाल कहता है "मैं ऑर्डर ऑब्जेक्ट की एक संपत्ति के आधार पर सूची को सॉर्ट करना चाहता हूं", लेकिन मैं मानता हूं कि कहीं और यह पूरी तरह से स्पष्ट नहीं है। किसी भी तरह से, यह एक बड़ा अंतर नहीं करता है कि क्या आपको एक या कई गुणों द्वारा सॉर्ट करने की आवश्यकता है।

— ल्यूक जूल

@ ल्यूक - अभी आगे फिर से पढ़ा था और मैं सहमत हूँ। 'मैं एक संपत्ति के आधार पर सूची को सॉर्ट करना चाहता हूं' ... और 'ऑर्डर दिनांक या ऑर्डर आईडी'। सभी उत्तरों के बीच, हमने सभी आधारों को कवर कर लिया है :)।

— djdd87

Answer 1

लिनक का उपयोग करने का सबसे आसान तरीका है:

List<Order> SortedList = objListOrder.OrderBy(o=>o.OrderDate).ToList();

Comments

मैं इसे अवरोही क्रम में कैसे सॉर्ट कर सकता हूं।

— प्यारा भालू

@BonusKun सूची <आदेश> SortedList = objListOrder। ऑर्डरबायस्केंडिंग (o => o.OrderDate) .ToList ();

— जवावजवज्जवजव

ध्यान दें कि यह मेमोरी में सभी वस्तुओं के साथ एक पूरी नई सूची बनाता है, जो प्रदर्शन के मामले में समस्याग्रस्त हो सकता है।

— stafafl

@staafl listWithObjects = listWithObjects.OrderByDescending(o => o.Status).ToList();ऐसे प्रयास के लिए पर्याप्त होगा?

— एंड्रयू ग्राइंडर

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

— लाजर

Answer 2

यदि आपको सूची को जगह में क्रमबद्ध करने की आवश्यकता है तो आप Sortएक Comparison<T>प्रतिनिधि को पास करते हुए विधि का उपयोग कर सकते हैं :

objListOrder.Sort((x, y) => x.OrderDate.CompareTo(y.OrderDate));

यदि आप इन-प्लेस के बजाय एक नया, क्रमबद्ध अनुक्रम बनाना पसंद करते हैं, तो आप LINQ की OrderByविधि का उपयोग कर सकते हैं , जैसा कि अन्य उत्तरों में बताया गया है।

Comments

हां, यह "सही" उत्तर है और एक नया IEnumerable बनाने और फिर इसे एक नई सूची में परिवर्तित करने की तुलना में बहुत अधिक कुशल होना चाहिए।

— जोनाथन वुड

बेशक, अगर आपको अवरोही प्रकार की आवश्यकता है, तो स्वैप xऔर yतीर के दाईं ओर =>।

— जेपी स्टिग नीलसन

वास्तविक उत्तर जो वास्तव में सूची में जगह

— बनाता है

@PimBrouwers यह बेहतर विकल्प अवधि है। यहां तक ​​कि अगर आप जिस मेमोरी का उपयोग कर रहे हैं, वह कोई समस्या नहीं है, तो यह समाधान अनावश्यक मेमोरी आवंटन से बचता है जो कि अत्यधिक महंगा है। यह विकल्प सरल कोडेज के रूप में है और तेजी से परिमाण का क्रम है।

— Cdaragorn

@JonSchneider के लिए Nullable<>( DateTime?उदाहरण के रूप में ले ) आप का उपयोग कर सकते हैं .Sort((x, y) => Nullable.Compare(x.OrderDate, y.OrderDate))जो अशक्त सभी गैर अशक्त मूल्यों से पहले के रूप में इलाज करेंगे। यह बिल्कुल वैसा ही है .Sort((x, y) => Comparer<DateTime?>.Default.Compare(x.OrderDate, y.OrderDate)।

— जेपी स्टिग नीलसन

Answer 3

LINQ on .net2.0 के बिना ऐसा करने के लिए:

List<Order> objListOrder = GetOrderList();
objListOrder.Sort(
    delegate(Order p1, Order p2)
    {
        return p1.OrderDate.CompareTo(p2.OrderDate);
    }
);

यदि आप .Net3.0 पर हैं, तो ल्यूक का जवाब है कि आप क्या कर रहे हैं।

कई गुणों पर सॉर्ट करने के लिए, आप इसे एक प्रतिनिधि के भीतर कर सकते हैं। उदाहरण के लिए:

orderList.Sort(
    delegate(Order p1, Order p2)
    {
        int compareDate = p1.Date.CompareTo(p2.Date);
        if (compareDate == 0)
        {
            return p2.OrderID.CompareTo(p1.OrderID);
        }
        return compareDate;
    }
);

यह आपको अवरोही क्रम के साथ आरोही तिथियां प्रदान करेगा।

हालांकि, मैं प्रतिनिधियों को चिपकाने की सलाह नहीं दूंगा क्योंकि इसका मतलब होगा कोड पुन: उपयोग के बिना बहुत सारे स्थान। आपको एक लागू करना चाहिए IComparerऔर बस अपने Sortतरीके से पास होना चाहिए । देखें यहाँ ।

public class MyOrderingClass : IComparer<Order>
{
    public int Compare(Order x, Order y)
    {
        int compareDate = x.Date.CompareTo(y.Date);
        if (compareDate == 0)
        {
            return x.OrderID.CompareTo(y.OrderID);
        }
        return compareDate;
    }
}

और फिर इस IComparer वर्ग का उपयोग करने के लिए, बस इसे तत्काल करें और इसे अपनी क्रमबद्ध विधि से पास करें:

IComparer<Order> comparer = new MyOrderingClass();
orderList.Sort(comparer);

Comments

उत्‍कृष्‍ट उत्‍तर, और सही होना चाहिए क्‍योंकि यह बेहतर सूची प्रदान करते हुए मूल सूची (जो LINQ वर्जन हमेशा करेगा) को पुन: प्रारंभ करने से बचाता है।

— जेब

@wonton, नहीं। यह विचार IComparerहमें अलग-अलग क्रियान्वयन करने में सक्षम बनाता है, जिससे हमें बहुरूपी व्यवहार मिलता है।

— राडारबॉब

मेरे लिए काम किया। मैंने इसका एक संस्करण छँटाई विकल्पों के साथ पोस्ट किया।

— जैक ग्रिफिन

Answer 4

सूची का उपयोग करने का सबसे सरल तरीका है OrderBy

 List<Order> objListOrder = 
    source.OrderBy(order => order.OrderDate).ToList();

यदि आप SQL क्वेरी का पालन करते हुए कई कॉलम जैसे ऑर्डर करना चाहते हैं।

ORDER BY OrderDate, OrderId

इसे प्राप्त करने के लिए आप ThenByनिम्नलिखित का उपयोग कर सकते हैं ।

  List<Order> objListOrder = 
    source.OrderBy(order => order.OrderDate).ThenBy(order => order.OrderId).ToList();

Answer 5

जैसा कि आपने कहा था, बिना Linq के ऐसा करना:

public class Order : IComparable
{
    public DateTime OrderDate { get; set; }
    public int OrderId { get; set; }

    public int CompareTo(object obj)
    {
        Order orderToCompare = obj as Order;
        if (orderToCompare.OrderDate < OrderDate || orderToCompare.OrderId < OrderId)
        {
            return 1;
        }
        if (orderToCompare.OrderDate > OrderDate || orderToCompare.OrderId > OrderId)
        {
            return -1;
        }

        // The orders are equivalent.
        return 0;
    }
}

तो बस अपने आदेश की सूची पर .sort () कॉल करें

Comments

पहले कलाकारों nullपर परीक्षण करना चाहिए as। जो कि पूरे बिंदु है as, जैसे (हा, हा) (Order)objएक अपवाद फेंकता है जब वह विफल हो जाता है। if(orderToCompare == null) return 1;।

— राडारबॉब

इंटरफ़ेस का उपयोग करने के लिए +1, जो कोड को बनाए रखने में आसान बनाता है और ऑब्जेक्ट की क्षमताओं को स्पष्ट रूप से उजागर करता है।

— aeonOfTime

- यदि विधेयक और टेड कभी दिखाई मैं मुझे वापस अक्टू 16, 2014 तक लेने के लिए तो मैं ऊपर मेरी गलती को सही कर सकते उन्हें पूछेंगे asरिटर्न nullअगर डाली विफल रहता है। लेकिन कम से कम अशक्त-परीक्षण सही है।

— रडारऑब

@ शरदबोब हां .. उफ़। :) परंतु! इस फ़ंक्शन का उपयोग किसी सूची पर एक प्रकार से स्वचालित रूप से उपयोग किए जाने के लिए किया जाता है, List<Order>इसलिए इस प्रकार की गारंटी दी जानी चाहिए asताकि आप 2014 पर मैच कर सकें, आपने शायद बग नहीं लिखा है, इसलिए अनावश्यक गार्ड स्टेटमेंट से परहेज करें :)

— जिमी हॉफ

दिलचस्प बिंदु की गारंटी होनी चाहिए । अगर इसे अच्छी तरह से समझाया गया है तो इसे पास नहीं किया जा सकता है, सिवाय पास के List<Order>; लेकिन आप और मैं दोनों आत्म-प्रेरित प्रोग्रामर से मिल चुके हैं, जो किसी को नहीं

— मानते हैं

Answer 6

एक शास्त्रीय वस्तु उन्मुख समाधान

पहले मुझे LINQ की अजीबोगरीब बातों से रूबरू होना चाहिए .... अब जब कि हम इस रास्ते से हट गए हैं

जिमीहॉफ जवाब पर एक बदलाव। जेनरिक के साथ CompareToपैरामीटर सुरक्षित हो जाता है।

public class Order : IComparable<Order> {

    public int CompareTo( Order that ) {
        if ( that == null ) return 1;
        if ( this.OrderDate > that.OrderDate) return 1;
        if ( this.OrderDate < that.OrderDate) return -1;
        return 0;
    }
}

// in the client code
// assume myOrders is a populated List<Order>
myOrders.Sort(); 

यह डिफ़ॉल्ट सॉर्टिबिलिटी निश्चित रूप से पुन: प्रयोज्य है। यही कारण है कि प्रत्येक ग्राहक को क्रमबद्ध तर्क को फिर से लिखना नहीं पड़ता है। "1" और "-1" (या तर्क ऑपरेटरों, आपकी पसंद) को स्वैप करने से क्रम क्रम उलट जाता है।

Comments

सूची में वस्तुओं को छांटने का सरल तरीका। लेकिन मुझे समझ नहीं आ रहा है कि आप 1 लौटाते हैं अगर (= = नल)?

— नियंत्रण रेखा Huynh

इसका मतलब है कि thisवस्तु अशक्त से अधिक है। छांटने के प्रयोजनों के लिए, एक अशक्त वस्तु संदर्भ "वस्तु" से कम है this। बस यही तरीका है कि मैंने यह परिभाषित करने का फैसला किया कि नल कैसे सुलझेंगे।

— राडारबॉब

Answer 7

// पूरी तरह से सामान्य ग्रिड ग्रिड के साथ उपयोग के लिए छँटाई

public List<T> Sort_List<T>(string sortDirection, string sortExpression, List<T> data)
    {

        List<T> data_sorted = new List<T>();

        if (sortDirection == "Ascending")
        {
            data_sorted = (from n in data
                              orderby GetDynamicSortProperty(n, sortExpression) ascending
                              select n).ToList();
        }
        else if (sortDirection == "Descending")
        {
            data_sorted = (from n in data
                              orderby GetDynamicSortProperty(n, sortExpression) descending
                              select n).ToList();

        }

        return data_sorted;

    }

    public object GetDynamicSortProperty(object item, string propName)
    {
        //Use reflection to get order type
        return item.GetType().GetProperty(propName).GetValue(item, null);
    }

Comments

या, आप जानते हैं, data.OrderBy()। थोड़ा आसान है कि पहिया का फिर से आविष्कार।

— gunr2171

विचार यह है कि यह किसी भी प्रकार की वस्तु के साथ काम करेगा। जहां ऑर्डरबी के रूप में () केवल दृढ़ता से टाइप की गई वस्तुओं के साथ काम करता है।

— रोगर

Thx a lot। मेरी राय में, ग्रिड डेटा सॉर्ट करने वाला सबसे सरल और प्रयोग करने योग्य समाधान!

— कोस्तस च।

Answer 8

यहाँ एक सामान्य LINQ एक्सटेंशन विधि है जो सूची की एक अतिरिक्त प्रतिलिपि नहीं बनाती है:

public static void Sort<T,U>(this List<T> list, Func<T, U> expression)
    where U : IComparable<U>
{
    list.Sort((x, y) => expression.Invoke(x).CompareTo(expression.Invoke(y)));
}

इसके प्रयेाग के लिए:

myList.Sort(x=> x.myProperty);

मैंने हाल ही में यह अतिरिक्त बनाया है जो एक स्वीकार करता है ICompare<U>, ताकि आप तुलना को अनुकूलित कर सकें। यह तब काम आया जब मुझे नेचुरल स्ट्रिंग सॉर्ट करने की जरूरत पड़ी:

public static void Sort<T, U>(this List<T> list, Func<T, U> expression, IComparer<U> comparer)
    where U : IComparable<U>
{    
    list.Sort((x, y) => comparer.Compare(expression.Invoke(x), expression.Invoke(y)));
}

Comments

मैंने इसे लागू किया है, ठीक काम करता है। मैंने "aAscending = true" पैरामीटर जोड़ा। अवरोही क्रम में सॉर्ट करने के लिए, बस x और y को दो इनवोक () विधियों के भीतर स्वैप करें। धन्यवाद।

— रोब एल

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

— 19

@ सरवी - वे सभी मान्य बिंदु हैं, लेकिन मैं ईमानदार रहूंगा, मुझे यकीन नहीं है कि कुछ कैसे (विशेष रूप से साइड इफेक्ट्स पैदा करने से एक चयनकर्ता को रोकना) को लागू करना है?)। मैंने उन्हें प्रतिनिधियों के लिए बदल दिया है। यदि आप जानते हैं कि उन परिवर्तनों में से कुछ को कैसे बनाया जाए, तो मुझे खुशी होगी कि आपने मेरा कोड संपादित किया।

— पीटर

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

— सेरी

voidइस भावना में एक विस्तार विधि लिखने का एक और अच्छा तरीका : static class Extensions { public static void SortBy<TSource, TKey>(this List<TSource> self, Func<TSource, TKey> keySelector) { self.SortBy(keySelector, Comparer<TKey>.Default); } public static void SortBy<TSource, TKey>(this List<TSource> self, Func<TSource, TKey> keySelector, IComparer<TKey> comparer) { self.Sort((x, y) => comparer.Compare(keySelector(x), keySelector(y))); } }एक SortByDescendingविधि द्वारा पूरक किया जा सकता है । @ सेवा की टिप्पणियाँ मेरे कोड पर भी लागू होती हैं!

— जेपी स्टिग नीलसन

Answer 9

LINQ का उपयोग करना

objListOrder = GetOrderList()
                   .OrderBy(o => o.OrderDate)
                   .ToList();

objListOrder = GetOrderList()
                   .OrderBy(o => o.OrderId)
                   .ToList();

Answer 10

//Get data from database, then sort list by staff name:

List<StaffMember> staffList = staffHandler.GetStaffMembers();

var sortedList = from staffmember in staffList
                 orderby staffmember.Name ascending
                 select staffmember;

Answer 11

रोजर के संस्करण में सुधार हुआ।

GetDynamicSortProperty के साथ समस्या यह है कि केवल संपत्ति के नाम प्राप्त करें लेकिन क्या होता है यदि GridView में हम NavigationProperties का उपयोग करते हैं? यह एक अपवाद भेज देगा, क्योंकि यह अशक्त है।

उदाहरण:

"Employee.Company.Name?" क्रैश हो जाएगा ... क्योंकि केवल "नाम" को एक पैरामीटर के रूप में इसके मूल्य को प्राप्त करने की अनुमति देता है।

यहां एक उन्नत संस्करण है जो हमें नेविगेशन गुणों द्वारा क्रमबद्ध करने की अनुमति देता है।

public object GetDynamicSortProperty(object item, string propName)
    {
        try
        {                 
            string[] prop = propName.Split('.'); 

            //Use reflection to get order type                   
            int i = 0;                    
            while (i < prop.Count())
            {
                item = item.GetType().GetProperty(prop[i]).GetValue(item, null);
                i++;
            }                     

            return item;
        }
        catch (Exception ex)
        {
            throw ex;
        }


    } 

Answer 12

आप गुणों के चयन के बारे में कुछ अधिक सामान्य कर सकते हैं, फिर भी आपके द्वारा चुने गए प्रकार के बारे में विशिष्ट होना चाहिए, आपके मामले में 'ऑर्डर':

एक सामान्य के रूप में अपने कार्य लिखें:

public List<Order> GetOrderList<T>(IEnumerable<Order> orders, Func<Order, T> propertySelector)
        {
            return (from order in orders
                    orderby propertySelector(order)
                    select order).ToList();
        } 

और फिर इसे इस तरह उपयोग करें:

var ordersOrderedByDate = GetOrderList(orders, x => x.OrderDate);

आप और भी अधिक सामान्य हो सकते हैं और एक खुले प्रकार को परिभाषित कर सकते हैं जिसे आप ऑर्डर करना चाहते हैं:

public List<T> OrderBy<T,P>(IEnumerable<T> collection, Func<T,P> propertySelector)
        {
            return (from item in collection
                    orderby propertySelector(item)
                    select item).ToList();
        } 

और इसे उसी तरह उपयोग करें:

var ordersOrderedByDate = OrderBy(orders, x => x.OrderDate);

जो LINQ शैली 'ऑर्डरबाय' करने का एक मूर्खतापूर्ण अनावश्यक जटिल तरीका है, लेकिन यह आपको एक सुराग दे सकता है कि इसे सामान्य तरीके से कैसे लागू किया जा सकता है

Answer 13

कृपया मुझे कुछ नमूना कोड के साथ @LukeH द्वारा उत्तर पूरा करने दें, जैसा कि मैंने परीक्षण किया है कि मुझे विश्वास है कि यह कुछ के लिए उपयोगी हो सकता है:

public class Order
{
    public string OrderId { get; set; }
    public DateTime OrderDate { get; set; }
    public int Quantity { get; set; }
    public int Total { get; set; }

    public Order(string orderId, DateTime orderDate, int quantity, int total)
    {
        OrderId = orderId;
        OrderDate = orderDate;
        Quantity = quantity;
        Total = total;
    }
}

public void SampleDataAndTest()
{
    List<Order> objListOrder = new List<Order>();

    objListOrder.Add(new Order("tu me paulo ", Convert.ToDateTime("01/06/2016"), 1, 44));
    objListOrder.Add(new Order("ante laudabas", Convert.ToDateTime("02/05/2016"), 2, 55));
    objListOrder.Add(new Order("ad ordinem ", Convert.ToDateTime("03/04/2016"), 5, 66));
    objListOrder.Add(new Order("collocationem ", Convert.ToDateTime("04/03/2016"), 9, 77));
    objListOrder.Add(new Order("que rerum ac ", Convert.ToDateTime("05/02/2016"), 10, 65));
    objListOrder.Add(new Order("locorum ; cuius", Convert.ToDateTime("06/01/2016"), 1, 343));


    Console.WriteLine("Sort the list by date ascending:");
    objListOrder.Sort((x, y) => x.OrderDate.CompareTo(y.OrderDate));

    foreach (Order o in objListOrder)
        Console.WriteLine("OrderId = " + o.OrderId + " OrderDate = " + o.OrderDate.ToString() + " Quantity = " + o.Quantity + " Total = " + o.Total);

    Console.WriteLine("Sort the list by date descending:");
    objListOrder.Sort((x, y) => y.OrderDate.CompareTo(x.OrderDate));
    foreach (Order o in objListOrder)
        Console.WriteLine("OrderId = " + o.OrderId + " OrderDate = " + o.OrderDate.ToString() + " Quantity = " + o.Quantity + " Total = " + o.Total);

    Console.WriteLine("Sort the list by OrderId ascending:");
    objListOrder.Sort((x, y) => x.OrderId.CompareTo(y.OrderId));
    foreach (Order o in objListOrder)
        Console.WriteLine("OrderId = " + o.OrderId + " OrderDate = " + o.OrderDate.ToString() + " Quantity = " + o.Quantity + " Total = " + o.Total);

    //etc ...
}

Answer 14

var obj = db.Items.Where...

var orderBYItemId = obj.OrderByDescending(c => Convert.ToInt32(c.ID));

Answer 15

LiNQ का उपयोग करें OrderBy

List<Order> objListOrder=new List<Order> ();
    objListOrder=GetOrderList().OrderBy(o=>o.orderid).ToList();

Answer 16

GenericTypeTea की तुलना के आधार पर :
हम सॉर्टिंग झंडे जोड़कर अधिक लचीलापन प्राप्त कर सकते हैं:

public class MyOrderingClass : IComparer<Order> {  
    public int Compare(Order x, Order y) {  
        int compareDate = x.Date.CompareTo(y.Date);  
        if (compareDate == 0) {  
            int compareOrderId = x.OrderID.CompareTo(y.OrderID);  

            if (OrderIdDescending) {  
                compareOrderId = -compareOrderId;  
            }  
            return compareOrderId;  
        }  

        if (DateDescending) {  
            compareDate = -compareDate;  
        }  
        return compareDate;  
    }  

    public bool DateDescending { get; set; }  
    public bool OrderIdDescending { get; set; }  
}  

इस परिदृश्य में, आपको इसे सॉर्टिंग गुणों को सेट करने के लिए MyOrderingClass के रूप में स्पष्ट रूप से (बल्कि तब IComparer ) को तुरंत भेजना होगा
:

MyOrderingClass comparer = new MyOrderingClass();  
comparer.DateDescending = ...;  
comparer.OrderIdDescending = ...;  
orderList.Sort(comparer);  

Answer 17

उपरोक्त में से कोई भी उत्तर मेरे लिए पर्याप्त नहीं था इसलिए मैंने इसे बनाया:

var someUserInputStringValue = "propertyNameOfObject i.e. 'Quantity' or 'Date'";
var SortedData = DataToBeSorted
                   .OrderBy(m => m.GetType()
                                  .GetProperties()
                                  .First(n => 
                                      n.Name == someUserInputStringValue)
                   .GetValue(m, null))
                 .ToList();

हालांकि बड़े पैमाने पर डेटा सेट पर सावधान। यह आसान कोड है, लेकिन यदि संग्रह विशाल है और संग्रह के ऑब्जेक्ट प्रकार में बड़ी संख्या में फ़ील्ड हैं, तो आपको परेशानी हो सकती है। भागो समय NxM है जहां:

संग्रह में तत्वों का एन = #

वस्तु के भीतर M = # गुण

Answer 18

किसी भी अशक्त प्रकार के साथ काम Valueकरने वाले को उपयोग करने की आवश्यकता होती है CompareTo।

objListOrder.Sort((x, y) => x.YourNullableType.Value.CompareTo(y.YourNullableType.Value));

Answer 19

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

और जब संभव हो तो प्रतिबिंब का उपयोग करके सामान्य कार्यान्वयन से बचें, इससे प्रदर्शन संबंधी समस्याएं भी हो सकती हैं।

Comments

यह अधिक प्रदर्शनकारी कैसे हो सकता है? सॉर्ट की गई सूची में डेटा सम्मिलित करना O (n) है, इसलिए n आइटम जोड़ना O (n ^ 2) है। क्या यह कई समवर्ती वस्तुओं को जोड़ने की कोशिश कर रहा है? ऐसे हालात हैं जब आपके पास अतिरिक्त सीपीयू चक्र हैं, जबकि आइटम जोड़े जा रहे हैं, लेकिन यह एक अच्छा सामान्य समाधान नहीं है।

— जॉन ला रूय

Answer 20

मान लें कि आपके पास निम्न कोड है, इस कोड में, हमारे पास कुछ गुणों के साथ एक यात्री वर्ग है जिसे हम आधार पर क्रमबद्ध करना चाहते हैं।

public class Passenger
{
    public string Name { get; }
    public string LastName { get; }
    public string PassportNo { get; }
    public string Nationality { get; }

    public Passenger(string name, string lastName, string passportNo, string nationality)
    {
        this.Name = name;
        this.LastName = lastName;
        this.PassportNo = passportNo;
        this.Nationality = nationality;
    }

    public static int CompareByName(Passenger passenger1, Passenger passenger2)
    {
        return String.Compare(passenger1.Name, passenger2.Name);
    }

    public static int CompareByLastName(Passenger passenger1, Passenger passenger2)
    {
        return String.Compare(passenger1.LastName, passenger2.LastName);
    }

    public static int CompareNationality(Passenger passenger1, Passenger passenger2)
    {
        return String.Compare(passenger1.Nationality, passenger2.Nationality);
    }
}

public class TestPassengerSort
{
    Passenger p1 = new Passenger("Johon", "Floid", "A123456789", "USA");
    Passenger p2 = new Passenger("Jo", "Sina", "A987463215", "UAE");
    Passenger p3 = new Passenger("Ped", "Zoola", "A987855215", "Italy");

    public void SortThem()
    {
        Passenger[] passengers = new Passenger[] { p1, p2, p3 };
        List<Passenger> passengerList = new List<Passenger> { p1, p2, p3 };

        Array.Sort(passengers, Passenger.CompareByName);
        Array.Sort(passengers, Passenger.CompareByLastName);
        Array.Sort(passengers, Passenger.CompareNationality);

        passengerList.Sort(Passenger.CompareByName);
        passengerList.Sort(Passenger.CompareByLastName);
        passengerList.Sort(Passenger.CompareNationality);

    }
}

तो आप संरचना प्रतिनिधि का उपयोग करके अपनी तरह की संरचना को लागू कर सकते हैं।