Why Lambda expression syntax in C Sharp (C#)? - Purpose & Use Cases

The Big Idea

What if you could write tiny functions in just one line, right where you need them?

The Scenario

Imagine you want to write a small piece of code that sorts a list of names by their length. Doing this manually means writing a full method with a name, parameters, and return type just for this tiny task.

The Problem

Writing full methods for simple tasks is slow and clutters your code. It's like writing a whole paragraph to say one sentence. It's easy to make mistakes and hard to read when you come back later.

The Solution

Lambda expressions let you write these small pieces of code quickly and clearly, right where you need them. They are like shorthand notes that do the job without extra fuss.

Before vs After

✗ Before

int CompareByLength(string s1, string s2) { return s1.Length - s2.Length; }
names.Sort(CompareByLength);

✓ After

names.Sort((s1, s2) => s1.Length.CompareTo(s2.Length));

What It Enables

Lambda expressions make your code shorter, easier to read, and faster to write, especially for small tasks.

Real Life Example

When filtering a list of products to find only those cheaper than $20, a lambda lets you write the filter condition right inside the method call without creating a separate function.

Key Takeaways

Manual methods for small tasks are slow and bulky.

Lambdas provide a quick, inline way to write small functions.

This makes code cleaner, easier, and faster to write.

Practice

1. What does the lambda expression x => x * 2 represent in C#?

easy

A. A variable declaration

B. A function that doubles the input value

C. A loop that runs twice

D. A conditional statement

Solution

1. Step 1: Understand lambda syntax

   The expression x => x * 2 means a function taking input x and returning x * 2.

2. Step 2: Interpret the operation

   It doubles the input value by multiplying it by 2.

3. Final Answer:

   A function that doubles the input value -> Option B

4. Quick Check:

   Lambda x => x * 2 doubles input [OK]

Hint: Lambda uses => to define short functions quickly [OK]

Common Mistakes:

• Thinking lambda is a variable
• Confusing lambda with loops
• Assuming lambda is a conditional

2. Which of the following is the correct syntax for a lambda expression that takes two integers and returns their sum?

easy

A. (a, b) => a + b

B. a, b => a + b

C. (a, b) => { a + b }

D. (a, b) => a + b;

Solution

1. Step 1: Check parameter syntax

   Parameters must be enclosed in parentheses when there is more than one, so (a, b) is correct.

2. Step 2: Check expression body

   The expression a + b without braces is valid for single expressions. (a, b) => a + b matches this.

3. Final Answer:

   (a, b) => a + b -> Option A

4. Quick Check:

   Two parameters need parentheses and expression body [OK]

Hint: Use parentheses for multiple parameters in lambda [OK]

Common Mistakes:

• Omitting parentheses for multiple parameters
• Adding semicolon inside lambda expression
• Using braces without return keyword incorrectly

3. What is the output of the following C# code?

Func<int, int> square = x => x * x;
Console.WriteLine(square(4));

medium

A. Compilation error

B. 8

C. 4

D. 16

Solution

1. Step 1: Understand the lambda function

   The lambda x => x * x returns the square of the input number.

2. Step 2: Calculate the output for input 4

   4 * 4 = 16, so square(4) returns 16.

3. Final Answer:

   16 -> Option D

4. Quick Check:

   Square of 4 is 16 [OK]

Hint: Lambda returns expression result directly if no braces [OK]

Common Mistakes:

• Confusing multiplication with addition
• Expecting lambda to print instead of return
• Thinking lambda causes syntax error

4. Identify the error in this lambda expression:

Func<int, int> add = (x, y) => x + y;

medium

A. Parentheses around parameters are not allowed

B. Missing return keyword inside lambda

C. Lambda has too many parameters for Func<int, int>

D. Lambda expression syntax is correct

Solution

1. Step 1: Check Func delegate signature

   Func<int, int> expects one input parameter and one output (int).

2. Step 2: Compare lambda parameters

   The lambda has two parameters (x, y), which does not match the delegate expecting one.

3. Final Answer:

   Lambda has too many parameters for Func<int, int> -> Option C

4. Quick Check:

   Func<int, int> means one input, one output [OK]

Hint: Match lambda parameters count with delegate type [OK]

Common Mistakes:

• Assuming multiple parameters allowed for Func
• Forgetting delegate parameter count rules
• Thinking return keyword is always needed

5. Given a list of integers, which lambda expression correctly filters out all even numbers using List<int>.Where()?

var numbers = new List<int> {1, 2, 3, 4, 5, 6};
var odds = numbers.Where( /* which lambda? */ );

hard

A. x => x % 2 == 1

B. x => x % 2 = 1

C. x => { return x % 2 == 0; }

D. x => x / 2 == 1

Solution

1. Step 1: Understand filtering condition

   We want to keep odd numbers, so condition is x % 2 == 1.

2. Step 2: Check lambda syntax and logic

   x => x % 2 == 1 uses correct syntax and logic to filter odds. x => x % 2 = 1 uses assignment (=) which is invalid. x => { return x % 2 == 0; } filters evens, not odds. x => x / 2 == 1 checks division, not oddness.

3. Final Answer:

   x => x % 2 == 1 -> Option A

4. Quick Check:

   Filter odds with modulo == 1 [OK]

Hint: Use == for comparison, % 2 == 1 filters odd numbers [OK]

Common Mistakes:

• Using = instead of == in lambda
• Filtering evens instead of odds
• Confusing division with modulo