Ordering Operators in LINQ

Back to: CSharp LINQ and Lambda Expressions Tutorial

Ordering Operators in LINQ are powerful tools that allow you to sort and order collections of data in C# easily. These operators allow you to sort data in ascending or descending order, and even sort by multiple properties at the same time. In this lesson, we’ll explore the different ordering operators available in LINQ, how to use them, and provide examples and tips to help you master these operators.

The ordering operators in LINQ include OrderBy, OrderByDescending, ThenBy, and ThenByDescending. These operators can be used to sort collections of data in ascending or descending order, and sort by multiple properties at the same time.

The basic syntax for using these operators is:

var orderedData = collection.OrderBy(x => x.PropertyName);

Here, collection is the collection of data you want to sort, and PropertyName is the name of the property you want to sort by. The OrderBy operator returns a new collection that is sorted based on the specified property in ascending order.

To sort in descending order, you can use the OrderByDescending operator:

var orderedData = collection.OrderByDescending(x => x.PropertyName);

You can also sort by multiple properties at the same time by chaining multiple OrderBy or OrderByDescending operators together:

var orderedData = collection.OrderBy(x => x.Property1).ThenByDescending(x => x.Property2);

Here, we first sort the collection by Property1 in ascending order, and then sort the resulting collection by Property2 in descending order.

The ThenBy and ThenByDescending operators are used to sort by multiple properties. These operators are chained together with OrderBy or OrderByDescending to sort by multiple properties.

One important thing to note is that the ordering operators in LINQ do not modify the original collection. Instead, they return a new sorted collection. If you want to sort the original collection in place, you can use the List.Sort() method:

collection.Sort((x, y) => x.PropertyName.CompareTo(y.PropertyName));

Here, we use a lambda expression to specify the comparison logic for sorting. This is a more low-level approach compared to the LINQ ordering operators, but it can be useful in some cases.

Now let’s take a look at some tips and examples for using the ordering operators in LINQ:

Sorting by multiple properties: As mentioned earlier, you can sort by multiple properties by chaining multiple OrderBy or OrderByDescending operators together. This can be very useful when you want to sort by a primary property and then by a secondary property if the primary property values are equal.
Sorting by a custom comparison logic: Sometimes, the default comparison logic used by the ordering operators may not be sufficient for your needs. In such cases, you can define a custom comparison logic using a lambda expression or a custom comparison class and pass it to the OrderBy or OrderByDescending operators.
Sorting by a calculated value: You can also sort by a calculated value using a lambda expression. For example, if you have a collection of Person objects and you want to sort by the length of their names, you can do the following:
```
var orderedData = collection.OrderBy(x => x.Name.Length);
```
In conclusion, the ordering operators in LINQ are powerful tools that allow you to sort and order collections of data in C# easily. By mastering these operators, you can easily sort your data and make it more organized and easier to work with.

Stay Connected