Sorting a list in .Net by one field, then another

I have list of objects I need to sort based on some of their properties. This works fine to sort it by one field:

reportDataRows.Sort((x, y) => x["Comment1"].CompareTo(y["Comment1"]));
foreach (var row in reportDataRows) {
   ...
}

I see lots of examples on here that do this with only one field. But how do I sort by one field, then another? Or how about a list of many fields? It seems like using LINQ orderby thenby would be best, but I don't know enough about it to know how use it.

For the parameters, something like this that supports any number of fields to sort by would be nice:

var sortBy = new List<string>(){"Comment1","Time"};

I don't want to be writing code to do this in every one of my apps. I plan on moving this sort code to the class that holds the data so that it can do more advanced things like using a list of parameters and implicitly recognizing that the field is a date and sorting it as a date instead of a string. The reportDataRow object contains fields with this information, so I don't have to do any messy checks to find out if the field is supposed 开发者_开发知识库to be a date.

---

Yes, I think it makes more sense to use OrderBy and ThenBy:

foreach (var row in reportDataRows.OrderBy(x => x["Comment1"]).ThenBy(x => x["Comment2"]) 
{
    ...
}

This assumes the other thing you want to order by is "Comment2".

---

Try this:

reportDataRows.Sort((x, y) =>
{
    var compare = x["Comment1"].CompareTo(y["Comment1"]);
    if(compare != 0)
        return compare;

    return x["Comment2"].CompareTo(y["Comment2"]);
});

---

You may want to look at this previous answer where I posted an extension method which handles multiple order by's in LINQ. This allows this sort of syntax:

myList.OrderByMany(x => x.Field1, x => x.Field2);

---

Look at the example for ThenBy on msdn.

---

If you're comparing your own objects, then you can implement the IComparable interface.
Otherwise, you can use the IComparer interface.

---

Using LINQ method syntax:

var sortedRows = reportDataRows.OrderBy(r => r["Comment1"])
                   .ThenBy(r => r["AnotherField"];

foreach (var row in sortedRows) {
   ...
}

And even more readable using query comprehension syntax:

var sortedRows = from r in reportDataRows
                 orderby r["Comment1"], r["Comment2"]
                 select r;
foreach (var row in sortedRows) {
   ...
}

---

You got it. Enumerable.OrderBy().ThenBy() is your ticket. It works exactly like it looks; elements are sorted by each projection, with ties decided by comparing the next projection. You can chain as many ThenBys as you want, and there are also OrderByDesc and ThenByDesc methods that will sort that projection in descending order.

As Albin has pointed out, An OrderBy chain does not touch the original list unless you assign the result of the ordering back to the original variable, like this:

reportDataRows = reportDataRows.OrderBy(x=>x.Comment1).ThenBy(x=>x.Comment2).ToList();

As a rule, OrderBy will perform slightly slower than List.Sort(); the algorithm is designed to work on any IEnumerable series of elements, so in order to sort (which requires knowing every element of the series) it slurps its entire source enumerable into a new array. However, OrderBy has a distinct advantage over Sort in that it is a "stable" sort; elements that are exactly equal to each other will retain their "relative order" in the sorted enumerable (the first of the two that you;d encounter when iterating through the unsorted list will be the first of the two encountered when iterating through the sorted list).