LINQ如何按给定标准对项目进行排序？

Question

Suppose we have a MyData class which implements the IComparable<MyData> and IComparable interfaces. Then we have a list containing many of MyData elements and a LINQ query to get a sorted list.

public class MyData : IComparable<MyData>, IComparable
{
    ...

    public int CompareTo(MyData value)
    {
        // TODO
    }

    public int CompareTo(object value)
    {
        if (value == null)
            return 1;

        if (value.GetType() == typeof(MyData))
        {
            MyData rightValue = (MyData)value;
            return (this.CompareTo(rightValue));
        }
        else throw new ArgumentException("Object is not a " + typeof(MyData) + ".");
    }
}

// main method
List<MyData> list = new List<MyData>();
...
var items = from item in list
            orderby item descending
            select item;

When LINQ sorts the elements within the list , does it use the implementation of IComparable interface in the MyData class?

If the answer is yes , is it better to encapsulate the sort criteria in the class MyData (by implementing the above interfaces) or specify the criteria in a LINQ query (without MyData that implements these interfaces)? What are the pros and cons of these two choices?

Answer 1

Enumerable.OrderBy "compares keys by using the default comparer Default ", which in turn will use your IComparable<T> implementation.

If the answer is yes, is it better to encapsulate the sort criteria in the class MyData (by implementing the above interfaces) or specify the criteria in a LINQ query (without MyData that implements these interfaces)? What are the pros and cons of these two choices?

So first, the answer is yes.

Both approaches have advantages.

Implementing IComparable<T> suggests that the type has a natural ordering. When this is true, I like implementing this interface. The main pro, in terms of LINQ, is that you simplify your LINQ queries (a bit). However, my main pro is more the suggestion of a "natural" order for that given type, which, in turn, adds to the clarity of your API.

The main pro of specifying the criteria in the LINQ query itself is flexibility. This allows you to sort by any number of criteria - not restricting yourself to a given sort defined in the type itself. If there isn't a "natural" sorting order for the type (ie: it's not representing something that is a "quantity" all on its own or similar), then I'd personally use this method.

Answer 2

The OrderBy extension methods take Func<> delegate - this is what is used to select the item used for sorting. One of the overloads takes an IComparer instance to use for comparisons - the ones that don't use the Default comparer.

Take a look at EduLinq - an educational re-implementation of LINQ by Jon Skeet to see how this is done - here is the OrderBy post .

Answer 3

In this case it uses Enumerable.OrderBy , which uses the Default Comparer:

This method compares keys by using the default comparer Default.

This method performs a stable sort; that is, if the keys of two elements are equal, the order of the elements is preserved. In contrast, an unstable sort does not preserve the order of elements that have the same key.

It is probably important to note that were you using Linq2SQL or some other LINQ provider, this is not necessarily the case. This only holds true because this is the IEnumerable implementation (Linq2Objects).