使用LiNQ OrderBy

List<Order> objListOrder=new List<Order> ();
    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”方式，但它可能会给你一个如何以通用方式实现的线索

如果需要对列表进行排序，则可以使用sort方法，传递Comparison＜T＞委托：

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

如果您希望创建一个新的排序序列而不是就地排序，那么可以使用LINQ的OrderBy方法，如其他答案中所述。

下面是一个通用LINQ扩展方法，它不会创建列表的额外副本：

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

要使用它：

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

我最近构建了另一个接受ICompare＜U＞的插件，以便您可以自定义比较。当我需要进行自然字符串排序时，这很有用：

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

经典的面向对象解决方案

首先，我必须向LINQ的伟大致敬。。。。现在我们已经把它排除在外了

JimmyHoffa答案的变体。使用泛型时，CompareTo参数变为类型安全。

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

当然，这个默认的可排序性是可重用的。也就是说，每个客户端不必冗余地重新写入排序逻辑。交换“1”和“-1”（或逻辑运算符，由您选择）可反转排序顺序。

我能想到的最简单的方法是使用Linq：

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