Cara Menyortir Daftar <T> berdasarkan properti di objek

Saya memiliki kelas yang disebut Orderyang memiliki properti sepertiOrderId , OrderDate, Quantity, dan Total. Saya punya daftar Orderkelas ini :

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

Sekarang saya ingin mengurutkan daftar berdasarkan pada satu properti Orderobjek, misalnya saya perlu mengurutkannya berdasarkan tanggal pesanan atau id pesanan.

Bagaimana saya bisa melakukan ini dalam C #?

Cara termudah yang bisa saya pikirkan adalah menggunakan Linq:

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

Jika Anda perlu mengurutkan daftar di tempat maka Anda dapat menggunakan Sortmetode ini, melewati Comparison<T>delegasi:

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

Jika Anda lebih suka membuat urutan baru yang diurutkan daripada mengurutkan di tempat maka Anda dapat menggunakan OrderBymetode LINQ , seperti yang disebutkan dalam jawaban lain.

Untuk melakukan ini tanpa LINQ di .Net2.0:

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

Jika Anda berada di .Net3.0, maka LukeH ini jawabannya adalah yang Anda cari.

Untuk mengurutkan beberapa properti, Anda masih bisa melakukannya di dalam delegasi. Sebagai contoh:

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;
    }
);

Ini akan memberi Anda tanggal naik dengan turun orderIds.

Namun, saya tidak akan merekomendasikan menempel delegasi karena akan berarti banyak tempat tanpa menggunakan kembali kode. Anda harus menerapkan IComparerdan hanya meneruskannya ke Sortmetode Anda . Lihat di sini .

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;
    }
}

Dan kemudian untuk menggunakan kelas IComparer ini, cukup instantiate dan berikan ke metode Sortir Anda:

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

Cara termudah untuk memesan daftar adalah menggunakan OrderBy

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

Jika Anda ingin memesan dengan beberapa kolom seperti mengikuti SQL Query.

ORDER BY OrderDate, OrderId

Untuk mencapai ini, Anda dapat menggunakan ThenByseperti berikut.

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

Melakukannya tanpa Linq seperti yang Anda katakan:

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;
    }
}

Kemudian panggil saja .sort () pada daftar Pesanan Anda

Solusi Berorientasi Objek Klasik

Pertama-tama saya harus mengarahkan pada kedahsyatan LINQ .... Sekarang kita sudah menyingkir

Variasi jawaban JimmyHoffa. Dengan obat generik, CompareToparameter menjadi aman.

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(); 

Sortasi default ini tentu saja dapat digunakan kembali. Artinya setiap klien tidak perlu menulis ulang logika sorting secara berlebihan. Mengganti "1" dan "-1" (atau operator logika, pilihan Anda) membalik urutan.

// Penyortiran yang benar-benar generik untuk digunakan dengan gridview

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);
    }

Berikut adalah metode ekstensi LINQ umum yang tidak membuat salinan tambahan dari daftar:

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)));
}

Untuk menggunakannya:

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

Baru-baru ini saya membuat tambahan ini yang menerima ICompare<U>, sehingga Anda dapat menyesuaikan perbandingan. Ini berguna ketika saya perlu melakukan semacam string alami:

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)));
}

Menggunakan LINQ

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

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

//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;

Peningkatan versi Roger.

Masalah dengan GetDynamicSortProperty adalah bahwa hanya mendapatkan nama properti tetapi apa yang terjadi jika di GridView kita menggunakan NavigationProperties? itu akan mengirim pengecualian, karena ia menemukan nol.

Contoh:

"Employee.Company.Name;" akan macet ... karena hanya mengizinkan "Nama" sebagai parameter untuk mendapatkan nilainya.

Berikut adalah versi yang disempurnakan yang memungkinkan kami untuk mengurutkan berdasarkan Properti Navigasi.

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;
        }


    } 

Anda dapat melakukan sesuatu yang lebih umum tentang pemilihan properti namun spesifik tentang jenis yang Anda pilih, dalam kasus Anda 'Pesan':

tulis fungsi Anda sebagai fungsi umum:

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

dan kemudian gunakan seperti ini:

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

Anda bisa menjadi lebih generik dan mendefinisikan tipe terbuka untuk apa yang ingin Anda pesan:

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

dan gunakan dengan cara yang sama:

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

Yang merupakan cara kompleks bodoh yang tidak perlu dalam melakukan gaya LINQ 'OrderBy', Tapi itu mungkin memberi Anda petunjuk tentang bagaimana hal itu dapat diterapkan dengan cara yang umum

Tolong izinkan saya menyelesaikan jawaban oleh @LukeH dengan beberapa kode sampel, karena saya telah mengujinya, saya yakin ini mungkin berguna untuk beberapa:

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 ...
}

var obj = db.Items.Where...

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

Manfaatkan LiNQ OrderBy

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

Berdasarkan GenericTypeTea 's Comparer:
kami dapat memperoleh lebih banyak fleksibilitas dengan menambahkan flag sorting:

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; }  
}  

Dalam skenario ini, Anda harus instantiate sebagai MyOrderingClass secara eksplisit (bukan IComparer )
untuk mengatur properti penyortirannya:

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

Tidak ada jawaban di atas yang cukup umum untuk saya, jadi saya buat yang ini:

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();

Hati-hati pada set data besar. Ini kode yang mudah tetapi bisa membuat Anda dalam kesulitan jika koleksi sangat besar dan jenis objek koleksi memiliki sejumlah besar bidang. Run time adalah NxM di mana:

N = # Elemen dalam koleksi

M = # Properti dalam Objek

Siapa pun yang bekerja dengan tipe nullable, Valuewajib menggunakan CompareTo.

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

Dari sudut pandang kinerja, yang terbaik adalah dengan menggunakan daftar yang diurutkan sehingga data diurutkan saat ditambahkan ke hasil. Pendekatan lain membutuhkan setidaknya satu iterasi ekstra pada data dan sebagian besar membuat salinan data sehingga tidak hanya kinerja tetapi penggunaan memori juga akan terpengaruh. Mungkin tidak menjadi masalah dengan beberapa elemen tetapi akan dengan ribuan, terutama dalam layanan di mana banyak permintaan bersamaan dapat melakukan penyortiran pada saat yang sama. Lihatlah System.Collections. namespace Umum dan pilih kelas dengan menyortir bukan Daftar.

Dan hindari implementasi generik menggunakan refleksi bila memungkinkan, ini dapat menyebabkan masalah kinerja juga.

Misalkan Anda memiliki kode berikut, dalam kode ini, kami memiliki kelas Penumpang dengan beberapa properti yang ingin kami urutkan berdasarkan.

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);

    }
}

Jadi, Anda dapat menerapkan struktur pengurutan dengan menggunakan delegasi Komposisi.