Cách sắp xếp danh sách <T> theo một thuộc tính trong đối tượng

Tôi có một lớp được gọi là Ordercó tính chất như OrderId, OrderDate, Quantity, và Total. Tôi có một danh sách của Orderlớp này :

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

Bây giờ tôi muốn sắp xếp danh sách dựa trên một thuộc tính của Orderđối tượng, ví dụ tôi cần sắp xếp nó theo ngày đặt hàng hoặc id đơn hàng.

Làm thế nào tôi có thể làm điều này trong C #?

Cách dễ nhất tôi có thể nghĩ là sử dụng Linq:

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

Nếu bạn cần sắp xếp danh sách tại chỗ thì bạn có thể sử dụng Sortphương thức, chuyển một Comparison<T>đại biểu:

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

Nếu bạn muốn tạo một chuỗi mới, được sắp xếp thay vì sắp xếp tại chỗ thì bạn có thể sử dụng OrderByphương pháp của LINQ , như đã đề cập trong các câu trả lời khác.

Để thực hiện việc này mà không cần LINQ trên .Net2.0:

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

Nếu bạn đang sử dụng .Net3.0, thì câu trả lời của LukeH là những gì bạn đang theo đuổi.

Để sắp xếp trên nhiều thuộc tính, bạn vẫn có thể thực hiện trong một đại biểu. Ví dụ:

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

Điều này sẽ cung cấp cho bạn ngày tăng dần với thứ tự giảm dần .

Tuy nhiên, tôi không khuyên bạn nên gắn bó với các đại biểu vì điều đó có nghĩa là nhiều nơi không sử dụng lại mã. Bạn nên thực hiện IComparervà chỉ cần chuyển nó qua Sortphương thức của bạn . Xem ở đây .

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

Và sau đó để sử dụng lớp IComparer này, chỉ cần khởi tạo nó và chuyển nó đến phương thức Sắp xếp của bạn:

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

Cách đơn giản nhất để đặt hàng một danh sách là sử dụng OrderBy

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

Nếu bạn muốn đặt hàng theo nhiều cột như truy vấn SQL.

ORDER BY OrderDate, OrderId

Để đạt được điều này bạn có thể sử dụng ThenBynhư sau.

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

Làm điều đó mà không có Linq như bạn nói:

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

Sau đó, chỉ cần gọi .sort () trong danh sách Đơn hàng của bạn

Một giải pháp hướng đối tượng cổ điển

Trước tiên, tôi phải tìm hiểu về sự tuyệt vời của LINQ .... Bây giờ chúng ta đã giải quyết được điều đó

Một biến thể về câu trả lời của JimmyHoffa. Với generic, CompareTotham số trở thành loại an toàn.

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

Tất nhiên, khả năng sắp xếp này có thể sử dụng lại. Đó là mỗi khách hàng không phải viết lại logic sắp xếp. Hoán đổi "1" và "-1" (hoặc các toán tử logic, lựa chọn của bạn) đảo ngược thứ tự sắp xếp.

// Sắp xếp hoàn toàn chung để sử dụng với 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);
    }

Đây là một phương pháp mở rộng LINQ chung không tạo thêm một bản sao của danh sách:

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

Để dùng nó:

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

Gần đây tôi đã xây dựng một bổ sung này chấp nhận một ICompare<U>, để bạn có thể tùy chỉnh so sánh. Điều này rất hữu ích khi tôi cần thực hiện sắp xếp chuỗi tự nhiên:

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

Sử dụng 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;

Một phiên bản cải tiến của Rogers.

Vấn đề với GetDAVESortProperty là chỉ lấy tên thuộc tính nhưng điều gì xảy ra nếu trong GridView chúng tôi sử dụng NavigationProperives? nó sẽ gửi một ngoại lệ, vì nó tìm thấy null.

Thí dụ:

"Employee.Company.Name;" sẽ sụp đổ ... vì chỉ cho phép "Tên" làm tham số để nhận giá trị của nó.

Đây là phiên bản cải tiến cho phép chúng tôi sắp xếp theo Thuộc tính Điều hướng.

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


    } 

Bạn có thể làm một cái gì đó chung chung hơn về lựa chọn thuộc tính nhưng cụ thể về loại bạn đang chọn, trong trường hợp của bạn 'Đặt hàng':

viết hàm của bạn như là một hàm chung:

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

và sau đó sử dụng nó như thế này:

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

Bạn thậm chí có thể chung chung hơn và xác định loại mở cho những gì bạn muốn đặt hàng:

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

và sử dụng nó theo cùng một cách:

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

Đó là một cách phức tạp không cần thiết ngu ngốc khi thực hiện kiểu 'OrderBy' theo kiểu LINQ, nhưng nó có thể cho bạn manh mối về cách thực hiện theo cách chung chung

Vui lòng để tôi hoàn thành câu trả lời của @LukeH với một số mã mẫu, vì tôi đã kiểm tra nó tôi tin rằng nó có thể hữu ích cho một số:

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

Sử dụng LiNQ OrderBy

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

Dựa trên Trình so sánh của GenericTypeTea :
chúng tôi có thể linh hoạt hơn bằng cách thêm các cờ sắp xếp:

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

Trong trường hợp này, bạn phải khởi tạo nó một cách rõ ràng dưới dạng MyOrderingClass (chứ không phải IComparer )
để đặt các thuộc tính sắp xếp của nó:

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

Không có câu trả lời nào ở trên đủ chung cho tôi nên tôi đã trả lời câu này:

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

Cẩn thận trên bộ dữ liệu lớn mặc dù. Đó là mã dễ dàng nhưng có thể khiến bạn gặp rắc rối nếu bộ sưu tập rất lớn và loại đối tượng của bộ sưu tập có số lượng lớn các trường. Thời gian chạy là NxM trong đó:

N = # của các yếu tố trong bộ sưu tập

M = # thuộc tính trong đối tượng

Bất kỳ ai làm việc với các loại nullable, Valueđược yêu cầu sử dụng CompareTo.

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

Từ quan điểm hiệu suất, tốt nhất là sử dụng một danh sách được sắp xếp để dữ liệu được sắp xếp khi nó được thêm vào kết quả. Các cách tiếp cận khác cần ít nhất một lần lặp thêm trên dữ liệu và hầu hết tạo ra một bản sao dữ liệu để không chỉ hiệu suất mà cả việc sử dụng bộ nhớ cũng bị ảnh hưởng. Có thể không phải là vấn đề với vài trăm yếu tố nhưng sẽ là hàng ngàn, đặc biệt là trong các dịch vụ nơi nhiều yêu cầu đồng thời có thể thực hiện sắp xếp cùng một lúc. Hãy xem không gian tên System.Collections.Generic và chọn một lớp có sắp xếp thay vì List.

Và tránh thực hiện chung bằng cách sử dụng sự phản chiếu khi có thể, điều này cũng có thể gây ra vấn đề hiệu suất.

Giả sử bạn có mã sau đây, trong mã này, chúng tôi có một lớp Hành khách với một vài thuộc tính mà chúng tôi muốn sắp xếp dựa trên.

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

    }
}

Vì vậy, bạn có thể thực hiện cấu trúc sắp xếp của mình bằng cách sử dụng ủy nhiệm Thành phần.