Comment trier une Liste<T> par une propriété de l'objet

Question

J'ai une classe appelée Order qui possède des propriétés telles que OrderId , OrderDate , Quantity et Total . J'ai une liste de ces Order classe :

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

Je veux trier la liste en fonction d'une propriété de l'élément Order par exemple, soit par la date de la commande, soit par l'identifiant de la commande.

Comment puis-je faire cela en C# ?

Answer 1

Le moyen le plus simple auquel je pense est d'utiliser Linq :

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

Answer 2

Si vous avez besoin de trier la liste sur place, vous pouvez utiliser la fonction Sort en passant un Comparison<T> délégué :

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

Si vous préférez créer une nouvelle séquence triée plutôt que de trier sur place, vous pouvez utiliser la fonction LINQ OrderBy comme indiqué dans les autres réponses.

Answer 3

Pour faire cela sans LINQ sur .Net2.0 :

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

Si vous êtes sur .Net3.0, alors la solution de LukeH réponse est ce que vous recherchez.

Pour trier sur plusieurs propriétés, vous pouvez toujours le faire dans un délégué. Par exemple :

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

Cela vous donnerait ascendant dates avec descendant orderIds.

Cependant, je ne recommanderais pas de s'en tenir aux délégués car cela signifierait beaucoup d'endroits sans réutilisation du code. Vous devriez implémenter un IComparer et de le transmettre à votre Sort méthode. Voir aquí .

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

Et pour utiliser cette classe IComparer, il suffit de l'instancier et de la passer à votre méthode Sort :

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

Answer 4

La manière la plus simple d'ordonner une liste est d'utiliser OrderBy

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

Si vous voulez commander par plusieurs colonnes comme la requête SQL suivante.

ORDER BY OrderDate, OrderId

Pour ce faire, vous pouvez utiliser ThenBy comme les suivantes.

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

Answer 5

Je le fais sans Linq comme vous l'avez dit :

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

Ensuite, il suffit d'appeler .sort() sur votre liste d'ordres.