LINQ OrderByDescending Method in C#

Back to: LINQ Tutorial For Beginners and Professionals

LINQ OrderByDescending Method in C# with Examples

In this article, I will discuss the LINQ OrderByDescending Method in C# with Examples. Please read our previous article discussing the LINQ OrderBy Method in C# with Examples. As part of this article, we will discuss the following pointers related to the LINQ OrderByDescending method.

1. What is the Linq OrderByDescending Method in C#?
2. Example of OrderByDescending Method using both Method and Query Syntax.
3. How to use the OrderByDescending Method with Complex Type in C#?
4. How do you use the OrderByDescending method along with the Filtering method?
5. How to Create and Use Own Comparer with OrderByDescending Method in C#?
6. When to Use Linq OrderByDescending Method in C#?

What is the Linq OrderByDescending Method in C#?

The LINQ OrderByDescending Method in C# is used to sort elements in a sequence in descending order according to a specified key. This is an extension method of the IEnumerable<T> and IQueryable<T> types and is found in the System.Linq namespace.

The point that you need to remember is that the OrderByDescending method will not change the data. It is just changing the order of the data. Like the OrderBy method, you can also use the OrderByDescending method on any data type, such as string, character, float, integer, etc. There are two overloaded versions of the OrderByDescending Method available inside LINQ. They are as follows.

The only difference between these two overloaded versions is that the second version takes the IComparer parameter, which compares the keys when creating our custom comparer. Let us understand using the LINQ OrderByDescending method in C# using both query syntax and method syntax using both primitive and reference data types.

LINQ OrderByDescending Method with Value Data Type in C#

Let us see an example of how the LINQ OrderByDescending Method works with Primitive Data Types such as Integer using C#. In the below example, we have a collection of integer data. And we need to sort the data in descending order. We use the LINQ OrderByDescending method using Method and Query Syntax for this.

using System;
using System.Collections.Generic;
using System.Linq;
namespace LINQDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            List<int> intList = new List<int>() { 10, 45, 35, 29, 100, 69, 58, 50 };

            Console.WriteLine("Before Sorting the Data: ");
            foreach (var item in intList)
            {
                Console.Write(item + " ");
            }

            //Sorting the data in Descending Order Using Method Syntax
            var MS = intList.OrderByDescending(num => num);

            //Sorting the data in Descending Order Using Query Syntax
            var QS = (from num in intList
                      orderby num descending
                      select num).ToList();

            Console.WriteLine();
            Console.WriteLine("After Sorting the Data in Descending Order: ");
            foreach (var item in QS)
            {
                Console.Write(item + " ");
            }

            Console.ReadKey();
        }
    }
}

Now, run the application, and you will get the following output.

Note: The OrderByDescending method sorts the elements of the source sequence in place and returns an IOrderedEnumerable<T> that can be enumerated to retrieve the sorted elements. It’s also often followed by ThenByDescending or ThenBy if you need to perform a secondary sort on the sequence.

LINQ OrderByDescending Method with String Data Type in C#

Let us see an example of how the LINQ OrderByDescending Method works with String Data Type using C#. In the below example, we have a collection of string data, i.e., a collection of names. We then sort the data in descending order using the LINQ OrderByDescending method with Method and Query syntax. In the Query Syntax, while we are sorting the data in descending order, the use of the descending operator is mandatory. If we omit the descending keyword, then by default, it will be ascending. 

using System;
using System.Collections.Generic;
using System.Linq;
namespace LINQDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            List<string> stringList = new List<string>() { "Preety", "Tiwary", "Priyanka", "Dewangan", "Hina", "Sharma"};

            Console.WriteLine("Before Sorting:");
            foreach (var item in stringList)
            {
                Console.Write(item + " ");
            }

            //Sorting in Descending Order Using Method Syntax
            var MS = stringList.OrderByDescending(name => name);

            //Sorting in Descending Order Using Query Syntax
            var QS = (from name in stringList
                      orderby name descending
                      select name).ToList();

            Console.WriteLine("\nAfter Sorting in Descending Order:");
            foreach (var item in MS)
            {
                Console.Write(item + " ");
            }

            Console.ReadKey();
        }
    }
}

When you run the above code, you will get the following output as expected.

LINQ OrderBy Method with Complex Data Type in C#:

Let us see how the LINQ OrderByDescending Method works with Complex Data Types in C# with Examples. We are going to work with the following Student class. So, create a class file named Student.cs and copy and paste the following code. As you can see, we created the Student class with four properties: ID, FirstName, LastName, and Brach. We then created one method, i.e., GetAllStudents(), to return a list of students.

using System.Collections.Generic;
namespace LINQDemo
{
    public class Student
    {
        public int ID { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Branch { get; set; }

        public static List<Student> GetAllStudents()
        {
            List<Student> listStudents = new List<Student>()
            {
                new Student{ID= 101,FirstName = "Preety",LastName = "Tiwary",Branch = "CSE"},
                new Student{ID= 102,FirstName = "Preety",LastName = "Agrawal",Branch = "ETC"},
                new Student{ID= 103,FirstName = "Priyanka",LastName = "Dewangan",Branch = "ETC"},
                new Student{ID= 104,FirstName = "Hina",LastName = "Sharma",Branch = "ETC"},
                new Student{ID= 105,FirstName = "Anugrag",LastName = "Mohanty",Branch = "CSE"},
                new Student{ID= 106,FirstName = "Anurag",LastName = "Sharma",Branch = "CSE"},
                new Student{ID= 107,FirstName = "Pranaya",LastName = "Kumar",Branch = "CSE"},
                new Student{ID= 108,FirstName = "Manoj",LastName = "Kumar",Branch = "ETC"},
                new Student{ID= 109,FirstName = "Pranaya",LastName = "Rout",Branch = "ETC"},
                new Student{ID= 110,FirstName = "Saurav",LastName = "Rout",Branch = "CSE"}
            };

            return listStudents;
        }
    }
}

Now, we want to sort the student data based on the Branch of the Student in descending order. To do so, modify the Main method of the Program class as follows. In the below code, we are Sorting the data in descending order based on the student Branch using the LINQ OrderByDescending Method with both Method and Query Syntax.

using System.Linq;
using System;
namespace LINQDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            //Method Syntax
            var MS = Student.GetAllStudents().OrderByDescending(x => x.Branch).ToList();

            //Query Syntax
            var QS = (from std in Student.GetAllStudents()
                      orderby std.Branch descending
                      select std);

            foreach (var student in MS)
            {
                Console.WriteLine(" Branch: " + student.Branch + ", Name :" + student.FirstName + " " + student.LastName);
            }
            
            Console.ReadKey();
        }
    }
}

When you run the above code, you will get the following output.

Linq OrderByDescending Method with Filtering Method

Now we need to fetch only the ETC branch students, and then we need to sort the students based on the FirstName in Descending order. The most important point you need to remember is to use the Where Extension method before the OrderByDescending method. This is because it will first filter and then sort the filtered results, improving the application’s performance. The following example uses LINQ OrderByDescending Method and LINQ Where Method with Query and Method Syntax.

using System.Linq;
namespace LINQDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            //Method Syntax
            var MS = Student.GetAllStudents()
                            .Where(std => std.Branch.ToUpper() == "ETC")
                            .OrderByDescending(x => x.FirstName).ToList();

            //Query Syntax
            var QS = (from std in Student.GetAllStudents()
                      where std.Branch.ToUpper() == "ETC"
                      orderby std.FirstName descending
                      select std);

            foreach (var student in QS)
            {
                Console.WriteLine(" Branch: " + student.Branch + ", Name :" + student.FirstName + " " + student.LastName);
            }

            Console.ReadKey();
        }
    }
}

When you run the above code, you will get the following output as expected.

How to Create and Use Own Comparer with LINQ OrderByDescending Method in C#?

Creating and using our own Comparer with the LINQ OrderByDescending Method is also possible. We need to use the Second Overloaded version of the OrderByDescending Method, which takes the IComparer parameter. For a better understanding, please have a look at the below example.

using System;
using System.Collections.Generic;
using System.Linq;
namespace LINQDemo
{
    public class CaseInsensitiveComparer : IComparer<string>
    {
        public int Compare(string x, string y)
        {
            return string.Compare(x, y, true);
        }
    }

    public class MainClass
    {
        public static void Main()
        {
            CaseInsensitiveComparer caseInsensitiveComparer = new CaseInsensitiveComparer();
            string[] Alphabets = { "a", "b", "c", "A", "B", "C" };
            var SortedAlphabets = Alphabets.OrderByDescending(aplhabet => aplhabet, caseInsensitiveComparer);
            foreach (var item in SortedAlphabets)
            {
                Console.Write(item + " ");
            }
            Console.Read();
        }
    }
}

Output: c C b B a A

When to Use LINQ OrderByDescending Method in C#?

You should use the LINQ OrderByDescending method in C# when sorting a sequence or collection of elements in descending order based on a specified key or property. This method is particularly useful in the following scenarios:

• Sorting Data in Descending Order: Use OrderByDescending to arrange elements in descending order based on a specific property or key. Example: Sorting a list of products by price in descending order to display the most expensive products first.
• Top-N Queries: When you need to retrieve the top N elements with the highest values according to a specific criterion, you can use OrderByDescending to sort the data and then use methods like Take to limit the result set. Example: Retrieving the top 10 highest-scoring players in a game leaderboard.
• Displaying Recent Items: If you want to display the most recent items or events first, use OrderByDescending to sort items by their timestamp or date. Example: Showing the most recent blog posts on a website.
• Comparing Elements by Numeric Value: When dealing with numeric values, you can use OrderByDescending to find the maximum or highest value in a collection. Example: Identifying the largest transaction amount in a list of financial transactions.
• Complex Queries: In more complex LINQ queries, OrderByDescending can be used to order data before performing other operations, such as filtering, grouping, or aggregating. Example: Grouping and displaying products by category, with the highest-priced product in each category shown first.
• Custom Sorting Criteria: You can provide custom sorting criteria using a lambda expression or delegate in the OrderByDescending method, allowing you to sort elements based on specific rules or calculations. Example: Sorting a list of employees by their performance score calculated from multiple factors.
• Database Queries: In database queries using LINQ to SQL or Entity Framework, OrderByDescending can be used to generate SQL queries that retrieve data in the desired order from the database.

In the next article, I will discuss LINQ ThenBy and ThenByDescending Methods in C# with Examples. I hope you enjoy this LINQ OrderByDescending Method with Examples article.