Lambda expression syntax in C Sharp (C#)

Introduction

Lambda expressions let you write small, quick functions without naming them. They make your code shorter and easier to read.

When you want to quickly define a function to pass as an argument.

When filtering or transforming lists or collections.

When writing event handlers or callbacks.

When you want to write simple functions inline without cluttering your code.

Syntax

C Sharp (C#)

(input_parameters) => expression_or_statement_block

If there is only one input parameter, parentheses around it are optional.

The right side can be a single expression or a block of statements inside { }.

Examples

A lambda that takes one input x and returns x squared.

C Sharp (C#)

x => x * x

A lambda that takes two inputs and returns their sum.

C Sharp (C#)

(x, y) => x + y

A lambda with explicit types and a statement block that returns the difference.

C Sharp (C#)

(int x, int y) => { return x - y; }

A lambda with no input parameters that prints a message.

C Sharp (C#)

() => Console.WriteLine("Hello")

Sample Program

This program uses lambda expressions to filter even numbers and to square each number in a list. It shows how lambdas make working with collections easy and clear.

C Sharp (C#)

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        List<int> numbers = new() { 1, 2, 3, 4, 5 };

        // Use lambda to filter even numbers
        var evens = numbers.Where(n => n % 2 == 0);

        Console.WriteLine("Even numbers:");
        foreach (var num in evens)
        {
            Console.WriteLine(num);
        }

        // Use lambda to square numbers
        var squares = numbers.Select(x => x * x);

        Console.WriteLine("Squares:");
        foreach (var sq in squares)
        {
            Console.WriteLine(sq);
        }
    }
}

Important Notes

Lambdas can capture variables from the surrounding code, which is called a closure.

Use lambdas to keep your code short and focused, especially when passing small functions.

Remember that lambdas can be assigned to delegates or expression trees depending on context.

Summary

Lambda expressions are short, unnamed functions written with => syntax.

They help write cleaner and shorter code for small functions.

You can use them anywhere a delegate or function is needed, like filtering or transforming data.

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