Descending Сортировать список в C # [дубликат]

Чтобы сделать это без LINQ на .Net2.0:

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

Если вы находитесь на .Net3.0, то ответ [LQH] LukeH - это то, что вы после .

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

Использование LINQ

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

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

Вы можете сделать что-то более общее в выборе свойств, но определенно о типе, который вы выбираете, в вашем случае «Заказ»:

записывать вашу функцию как общую:

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 «OrderBy», но он может дать вам представление о том, как он может быть реализован в общий способ

Ни один из вышеперечисленных ответов не был достаточно общим для меня, поэтому я сделал это:

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, где:

N = # элементов в коллекции

M = # свойств в объекте

На основе Comparer 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);  

var obj = db.Items.Where...

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

Выполнение этого без 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 () в свой список Orders