OrderBy and sorting in C Sharp (C#) - Step-by-Step Execution

Concept Flow - OrderBy and sorting

Start with collection

↓

Choose key to sort by

↓

Compare elements by key

↓

Rearrange elements in order

↓

Return sorted collection

↓

End

The program takes a collection, selects a key to sort by, compares elements, rearranges them, and returns the sorted collection.

Execution Sample

C Sharp (C#)

var numbers = new List<int> { 5, 3, 8, 1 };
var sorted = numbers.OrderBy(n => n);
foreach(var num in sorted) Console.Write(num + " ");

Sorts a list of numbers in ascending order and prints them.

Execution Table

Step	Action	Collection State	Output
1	Start with numbers list	[5, 3, 8, 1]
2	Apply OrderBy with key = number itself	[5, 3, 8, 1]
3	Compare elements and sort	[1, 3, 5, 8]
4	Iterate sorted collection	[1, 3, 5, 8]	1 3 5 8
5	End	[1, 3, 5, 8]	1 3 5 8

💡 All elements sorted ascending, iteration complete.

Variable Tracker

Variable	Start	After OrderBy	After Iteration	Final
numbers	[5, 3, 8, 1]	[5, 3, 8, 1]	[5, 3, 8, 1]	[5, 3, 8, 1]
sorted	null	[1, 3, 5, 8]	[1, 3, 5, 8]	[1, 3, 5, 8]
num	null	null	1, 3, 5, 8	8

Key Moments - 2 Insights

Why does the original list 'numbers' not change after OrderBy?

OrderBy returns a new sorted sequence without modifying the original list, as shown in execution_table rows 2 and 3 where 'numbers' stays the same but 'sorted' changes.

What does the lambda 'n => n' mean in OrderBy?

It means we sort by the number itself. The lambda picks each element as the key to sort by, as seen in execution_table step 2.

Visual Quiz - 3 Questions

Look at the execution_table, what is the collection state after sorting is applied?

A [8, 5, 3, 1]

B [5, 3, 8, 1]

C [1, 3, 5, 8]

D []

💡 Hint

Check execution_table row 3 under 'Collection State' to see the sorted list.

At which step does the program output the sorted numbers?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look at execution_table row 4 where 'Output' shows the printed numbers.

If we changed the lambda to 'n => -n', how would the sorted collection look?

A [8, 5, 3, 1]

B [1, 3, 5, 8]

C [5, 3, 8, 1]

D []

💡 Hint

Sorting by negative values reverses order; check how keys affect sorting in execution_table step 2.

Concept Snapshot

OrderBy sorts a collection by a key selector.
Syntax: collection.OrderBy(x => key)
Returns a new sorted sequence, original unchanged.
Sorts ascending by default.
Use lambda to pick sort key.
Iterate to see sorted results.

Full Transcript

This example shows how OrderBy sorts a list of numbers. We start with the list [5, 3, 8, 1]. OrderBy uses a lambda 'n => n' to sort by the number itself. It returns a new sorted sequence [1, 3, 5, 8] without changing the original list. Then we print each number in order. The key points are that OrderBy does not modify the original collection and that the lambda defines the sorting key.

Practice

1. What does the OrderBy method do in C#?

easy

A. Sorts a collection in ascending order based on a key

B. Deletes elements from a list

C. Reverses the order of elements in a list

D. Filters elements based on a condition

Solution

1. Step 1: Understand the purpose of OrderBy

   The OrderBy method sorts elements in a collection based on a key in ascending order.

2. Step 2: Compare with other options

   Options B, C, and D describe different operations (deletion, reversing, filtering) which OrderBy does not perform.

3. Final Answer:

   Sorts a collection in ascending order based on a key -> Option A

4. Quick Check:

   OrderBy = Sort ascending [OK]

Hint: OrderBy sorts ascending by key, not filtering or deleting [OK]

Common Mistakes:

• Confusing OrderBy with filtering methods like Where
• Thinking OrderBy modifies the original list
• Mixing up OrderBy with reversing or deleting

2. Which of the following is the correct syntax to sort a list of integers named numbers in ascending order using OrderBy?

easy

A. numbers.OrderBy();

B. numbers.OrderBy(n);

C. numbers.OrderBy(n => n);

D. numbers.OrderBy(n => );

Solution

1. Step 1: Check the correct lambda syntax

   OrderBy requires a key selector function like n => n to specify sorting key.

2. Step 2: Validate each option

   numbers.OrderBy(n => n); uses correct lambda syntax. numbers.OrderBy(); misses the key selector. numbers.OrderBy(n); passes a variable, not a lambda. numbers.OrderBy(n => ); has incomplete lambda syntax.

3. Final Answer:

   numbers.OrderBy(n => n); -> Option C

4. Quick Check:

   OrderBy needs a key selector lambda [OK]

Hint: OrderBy always needs a key selector lambda like n => n [OK]

Common Mistakes:

• Omitting the lambda expression inside OrderBy
• Passing a variable instead of a lambda
• Using incomplete or invalid lambda syntax

3. What will be the output of the following code?

var fruits = new List<string> { "banana", "apple", "cherry" };
var sorted = fruits.OrderBy(f => f);
foreach(var fruit in sorted) {
    Console.Write(fruit + " ");
}

medium

A. banana apple cherry

B. apple banana cherry

C. cherry banana apple

D. apple cherry banana

Solution

1. Step 1: Understand the sorting key

   The code sorts the list of fruits alphabetically by their string value.

2. Step 2: Determine the sorted order

   Alphabetically, "apple" comes before "banana", which comes before "cherry".

3. Final Answer:

   apple banana cherry -> Option B

4. Quick Check:

   OrderBy sorts strings alphabetically [OK]

Hint: OrderBy sorts strings alphabetically ascending [OK]

Common Mistakes:

• Assuming original order is preserved
• Confusing OrderBy with OrderByDescending
• Not recognizing alphabetical order

4. The following code throws a compile-time error. What is the mistake?

var numbers = new List<int> { 3, 1, 2 };
var sorted = numbers.OrderBy();

medium

A. numbers must be an array, not a list

B. List<int> cannot be sorted

C. OrderBy should be OrderByDescending

D. OrderBy requires a key selector lambda expression

Solution

1. Step 1: Identify the method signature requirement

   OrderBy requires a key selector function to specify how to sort elements.

2. Step 2: Analyze the error cause

   Calling OrderBy() without any argument causes a compile error because the key selector is missing.

3. Final Answer:

   OrderBy requires a key selector lambda expression -> Option D

4. Quick Check:

   OrderBy needs a lambda key selector [OK]

Hint: Always provide a key selector lambda to OrderBy [OK]

Common Mistakes:

• Calling OrderBy without arguments
• Thinking OrderBy works without a key selector
• Confusing List and array types for sorting

5. Given a list of students with properties Name and Score, how do you sort the list first by Score descending, then by Name ascending using LINQ?

hard

A. students.OrderByDescending(s => s.Score).ThenBy(s => s.Name);

B. students.OrderBy(s => s.Score).OrderBy(s => s.Name);

C. students.OrderBy(s => s.Name).OrderByDescending(s => s.Score);

D. students.OrderByDescending(s => s.Name).ThenByDescending(s => s.Score);

Solution

1. Step 1: Understand multi-level sorting

   To sort by multiple keys, use OrderBy or OrderByDescending for the first key, then ThenBy or ThenByDescending for the next keys.

2. Step 2: Apply correct order and directions

   We want to sort by Score descending first, then by Name ascending, so use OrderByDescending(s => s.Score) followed by ThenBy(s => s.Name).

3. Final Answer:

   students.OrderByDescending(s => s.Score).ThenBy(s => s.Name); -> Option A

4. Quick Check:

   OrderByDescending + ThenBy for multi-level sort [OK]

Hint: Use ThenBy after OrderBy for secondary sorting [OK]

Common Mistakes:

• Using multiple OrderBy calls instead of ThenBy
• Mixing ascending and descending incorrectly
• Sorting by wrong property order