//用于网格视图的完全通用排序

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

我只是想回到问题上来。如果您要对该序列的列表进行排序，请选择“1”“10”“100”“200”“2”“20”“3”“30”“300”，然后按照表单1获取排序项目；2.3.10;20;30;100;200;300你可以使用这个：

 public class OrderingAscending : IComparer<String>
    {
        public int Compare(String x, String y)
        {
            Int32.TryParse(x, out var xtmp);
            Int32.TryParse(y, out var ytmp);

            int comparedItem = xtmp.CompareTo(ytmp);
            return comparedItem;
        }
    }

您可以在以下形式的代码隐藏中使用它：

 IComparer<String> comparerHandle = new OrderingAscending();
 yourList.Sort(comparerHandle);

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

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

要在.Net 2.0上不使用LINQ的情况下执行此操作，请执行以下操作：

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

如果你在.Net 3.0上，那么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;
    }
);

这将为您提供具有降序ID的升序日期。

然而，我不建议使用委托，因为这意味着很多地方没有代码重用。您应该实现一个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类，只需实例化它并将其传递给Sort方法：

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

您可以对财产选择做一些更通用的操作，但也可以对您选择的类型进行特定操作，例如“订单”：

将函数编写为通用函数：

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”方式，但它可能会给你一个如何以通用方式实现的线索

使用LINQ

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

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