c# - सूची <> क्रमशः वर्णमाला क्रम


मैं फ्रेमवर्क 3.5 पर सी # का उपयोग कर रहा हूँ। मैं एक जेनेरिक List<> को शीघ्र रूप से क्रमबद्ध करने के लिए देख रहा हूं List<> इस उदाहरण के लिए हमें बताता है कि मेरे पास अंतिम नाम की संपत्ति के साथ एक व्यक्ति की एक सूची है। मैं लैम्ब्डा अभिव्यक्ति का उपयोग करके इस सूची को कैसे सॉर्ट कर सकता हूं?

List<Person> people = PopulateList();
people.OrderBy(???? => ?????)



Answers


यदि आप एक इन-प्लेस सॉर्ट (अर्थात सूची अपडेट की गई है) का मतलब है:

people.Sort((x, y) => string.Compare(x.LastName, y.LastName));

यदि आप एक नई सूची का मतलब है:

var newList = people.OrderBy(x=>x.LastName).ToList(); // ToList optional



क्या आपको सूची की सूची की सामग्री को क्रमबद्ध करने की सूची की ज़रूरत है, या बस क्रमबद्ध अनुक्रम? उत्तरार्द्ध आसान है:

var peopleInOrder = people.OrderBy(person => person.LastName);

जगह में सॉर्ट करने के लिए, आपको एक IComparer<Person> या Comparison<Person> इसके लिए, आप ProjectionComparer कॉम्पैयरर पर MiscUtil में विचार कर सकते हैं।

(मुझे पता है मैं MiscUtil ऊपर लाते रहो - यह सिर्फ प्रासंगिक होता रहता है ...)




people.OrderBy(person => person.lastname).ToList();



आप linq का उपयोग कर सकते हैं :) का उपयोग कर:

System.linq;
var newList = people.OrderBy(x=>x.Name).ToList();



private void SortGridGenerico< T >(
          ref List< T > lista       
    , SortDirection sort
    , string propriedadeAOrdenar)
{

    if (!string.IsNullOrEmpty(propriedadeAOrdenar)
    && lista != null
    && lista.Count > 0)
    {

        Type t = lista[0].GetType();

        if (sort == SortDirection.Ascending)
        {

            lista = lista.OrderBy(
                a => t.InvokeMember(
                    propriedadeAOrdenar
                    , System.Reflection.BindingFlags.GetProperty
                    , null
                    , a
                    , null
                )
            ).ToList();
        }
        else
        {
            lista = lista.OrderByDescending(
                a => t.InvokeMember(
                    propriedadeAOrdenar
                    , System.Reflection.BindingFlags.GetProperty
                    , null
                    , a
                    , null
                )
            ).ToList();
        }
    }
}



मेरे लिए यह उपयोगी डमी गाइड - सामान्य सूची में छंटनी - काम किया यह आपको बहुत ही पूर्ण और स्पष्ट स्पष्टीकरण और सरल उदाहरणों के साथ इस कार्य को करने के लिए 4 तरीके (अधिभार) समझने में मदद करता है

  • सूची।
  • सूची। सार (जेनेरिक तुलना)
  • सूची। सर (जेनेरिक आईकॉम्पपरर)
  • सूची। थोर (इंट 32, इंट 32, जेनेरिक आईकॉम्पपरर)



आप इस कोड स्निपेट का उपयोग कर सकते हैं:

var New1 = EmpList.OrderBy(z => z.Age).ToList();

जहां New1 एक List<Employee>

EmpList एक List<Employee> चर है

z Employee प्रकार का एक चर है




आप भी उपयोग कर सकते हैं

model.People = model.People.OrderBy(x => x.Name).ToList();



यह एक सामान्य सॉर्टर है नीचे स्विच के साथ बुलाया

dvm.PagePermissions मेरे ViewModel प्रकार की सूची टी में एक संपत्ति है इस मामले में टी एक EF6 मॉडल वर्ग called page_permission है।

dvm.UserNameSortDir दृश्यमॉडल पर एक स्ट्रिंग गुण है जो अगले सॉर्ट दिशा रखता है। वह व्यक्ति जिसको दृष्टि में इस्तेमाल किया जाता है

switch (sortColumn)
{
    case "user_name":
        dvm.PagePermissions = Sort(dvm.PagePermissions, p => p.user_name, ref sortDir);
        dvm.UserNameSortDir = sortDir;
        break;
    case "role_name":
        dvm.PagePermissions = Sort(dvm.PagePermissions, p => p.role_name, ref sortDir);
        dvm.RoleNameSortDir = sortDir;
        break;
    case "page_name":
        dvm.PagePermissions = Sort(dvm.PagePermissions, p => p.page_name, ref sortDir);
        dvm.PageNameSortDir = sortDir;
        break;
}                 


public List<T> Sort<T,TKey>(List<T> list, Func<T, TKey> sorter, ref string direction)
    {
        if (direction == "asc")
        {
            list = list.OrderBy(sorter).ToList();
            direction = "desc";
        }
        else
        {
            list = list.OrderByDescending(sorter).ToList();
            direction = "asc";
        }
        return list;
    }