OrderBy中lambda表达式的重点是什么？

Question

I have a list of strings and I'd like to order them.

IEnumerable<String> strings = ...;
strings = strings.OrderBy(a => a);

What I don't get is the point of the lambda expression a => a in there. First I thought that I can pull out a property and order at the same like like this.

IEnumerable<Something> somethings = ...;
IEnumerable<String> strings = somethings.OrderBy(a => a.StringProperty);

But that doesn't compile. So I'll have to go like this.

IEnumerable<Something> somethings = ...;
IEnumerable<String> strings = somethings.Select(a
  => a.StringProperty).OrderBy(a => a);

So why am I enforced to use the lambda expression in the OrderBy command?!

Answer 1

The lambda indicates the "what you want to order by".

If you take a set of people, and order them by their birthday, you still have a set of people - not a set of birthdays; ie

IEnumerable<Person> people = ...;
IEnumerable<Person> sorted = people.OrderBy(a => a.DateOfBirth);

so similarly, ordering a set of Something s by StringProperty still results in a set of Something s:

IEnumerable<Something> somethings = ...;
IEnumerable<Something> sorted = somethings.OrderBy(a => a.StringProperty);

In some (very few) cases, you do actually mean "and order it by the thing itself". This usually applies only to things like IEnumerable<string> or IEnumerable<int> - so the minor inconvenience of .OrderBy(x => x) is trivial. If it bothers you, you could always write an extension method to hide this detail.

Answer 2

When you order a collection it doesn't change it's type, hence

IEnumerable<Something> somethings = ...; 
var strings = somethings.OrderBy(a => a.StringProperty);

results in an IEnumerable<Something> , you have to select the property to change the type:

IEnumerable<String> strings = somethings
    .OrderBy(s => s.StringProperty)
    .Select(s => s.StringProperty);

So why am I enforced to use the lambda expression in the OrderBy command?!

Because Enumerable.OrderBy is a method that needs an argument.

Answer 3

Because you're not selecting it, you're ordering by it.

Try this:

Console.WriteLine(string.Join(", ",
    new[] { new { Int = 1 }, new { Int = 2 }, new { Int = 0 }
    .OrderBy(a => a.Int));

This will give you the lists, ordered by the Int property, not just randomly ordered!

This means that you can order by any property of the object, instead of just the object itself.

Answer 4

the structure of the .OrderBy(TSource, TKey) method has a requirement for both the Source item and the item to sort by. the lambda is saying "Order TSource using TKey", or in your case, "Order a using a"

Answer 5

The purpose of the parameter lambda in OrderBy is precisely tell the criteria using for ordering. It takes an object you're sorting, and returns another "thing" (same type or not) which will be sorted, sort of extracting a key to be sorted from the original source.

Your first sample is really trivial, and your rant is somewhat justified there, since if you start from a list of strings, you most likely will want to sort by those strings precisely. Which makes me wonder too, why we can't have a parameterless OrderBy for those trivial cases.

For the second snippet:

IEnumerable<Something> somethings = ...;
IEnumerable<Something> strings = somethings.OrderBy(a => a.StringProperty);

Here is when the "sorting criteria" makes sense, as you order the objects by some property value derived from them, and not just for the objects themselves (which generally aren't comparable). The reason it doesn't compiles is in the second enumerable declaration, it should be an IEnumerable<Something> instead of IEnumerable<string> , because the ordering will return another list of the very same type as it received, but in a different order, regardless of sorting criteria .

In the third snippet, you solve that by Select ing the string property, that effectively yields a list of strings, but you lose all the input objects in the process. The lambda parameter is more or less pointless and trivial here, as you're starting from a plain string to begin with, the very same as the first sample.

Another way to use it would be to specify some different sorting criteria other than the trivial for strings. Say you want to sort not alphabetically, but by the third letter instead:

IEnumerable<String> strings = ...;
strings = strings.OrderBy(a => a.Substring(2, 1));