Lambda Expressions In C# Complete Guide

Step 1: Understanding Basic Syntax

Lambda expressions are written in the form input => expression or input => { statement; statement; ... }.

Simple Example:

Let’s start with a simple lambda expression that adds two numbers.

using System;

class Program
{
    static void Main()
    {
        // Define a delegate with two int parameters and returns an int
        Func<int, int, int> add = (x, y) => x + y;

        // Use the lambda expression
        Console.WriteLine(add(5, 3)); // Output: 8
    }
}

Explanation:

• Func<int, int, int> is a built-in delegate type representing a function with two int arguments and an int return type.
• (x, y) represents the input parameters.
• => is the lambda operator indicating what follows is the function body.
• x + y is the expression to execute, producing the return value.

Step 2: Lambda with a Single Statement vs. Multiple Statements

You can use single statements (no braces {} needed) or multiple statements.

Single Statement Lambda:

using System;

class Program
{
    static void Main()
    {
        // Define a Func delegate that takes one int parameter and returns its square.
        Func<int, int> square = x => x * x;

        // Using the lambda expression to calculate the square of 4.
        Console.WriteLine(square(4)); // Output: 16
    }
}

Explanation:

• In this example, the lambda expression x => x * x calculates the square of x.

Multiple Statements Lambda:

using System;

class Program
{
    static void Main()
    {
        // Define an Action delegate with one string parameter.
        Action<string> printWithExclamation = message =>
        {
            message += "!!!";
            Console.WriteLine(message);
        };

        // Using the lambda expression.
        printWithExclamation("Hello"); // Output: Hello!!!
    }
}

Explanation:

• Here, Action<string> is a delegate that takes one string argument and does not return any value.
• The lambda expression has multiple statements within the curly braces {}.

Step 3: Using Lambda Expressions with LINQ (Language Integrated Query)

One of the most common uses of lambda expressions is with LINQ queries in collections.

Complete Example with LINQ:

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        // Create an array of integers.
        int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        
        // Use LINQ to find all even numbers using a lambda expression.
        var evenNumbers = numbers.Where(n => n % 2 == 0);

        // Print the result.
        foreach (var number in evenNumbers)
        {
            Console.WriteLine(number); // Output: 2 4 6 8 10
        }

        // Use LINQ to calculate the sum of squares for all numbers using a lambda expression.
        int sumOfSquares = numbers.Sum(x => x * x);
        
        // Print the result.
        Console.WriteLine(sumOfSquares); // Output: 385
    }
}

Explanation:

• numbers.Where(n => n % 2 == 0) filters the numbers array to include only even numbers.
• numbers.Sum(x => x * x) computes the sum of the squares of the numbers in the array.

Step 4: Lambda with Implicit Typed Parameters

C# allows you to omit parameter types if it can be inferred from context:

Implicit Typed Parameter Example:

using System;

class Program
{
    static void Main()
    {
        // Define a Func delegate that takes one parameter and returns its square.
        Func<int, int> square = x => x * x;

        // Define an Action with implicit typed parameter.
        Action<object> displayObject = obj => Console.WriteLine(obj);

        // Using the lambda expression.
        Console.WriteLine(square(4)); // Output: 16

        // Displaying an object using the lambda.
        displayObject("Hello"); // Output: Hello
        displayObject(100);   // Output: 100
        displayObject(true);  // Output: True
    }
}

Explanation:

• Parameter types are omitted in displayObject because C# can infer them from usage.

Step 5: Using Expression<TDelegate> for More Advanced Scenarios

Expression<TDelegate> allows you to represent code as data, and it is often used in libraries for dynamic query construction.

Expression<TDelegate> Example:

using System;
using System.Linq.Expressions;

class Program
{
    static void Main()
    {
        // Define an expression that multiplies two numbers.
        Expression<Func<int, int, int>> multiplyExpr = (x, y) => x * y;
        
        // Compile it to a delegate.
        Func<int, int, int> multiply = multiplyExpr.Compile();
        
        // Using the lambda expression through the compiled delegate.
        Console.WriteLine(multiply(5, 3)); // Output: 15
    }
}

Explanation:

• Expression<Func<int, int, int>> defines a lambda expression that can be analyzed or converted to code rather than just executed.
• Compile() turns the expression into a delegate that you can call like a regular method.

Summary and Conclusion

Lambda expressions are a powerful feature in C# that simplify coding, especially when working with LINQ and other functional programming constructs. They come in two forms - with a single statement or multiple statements - and support both explicit and implicit typing. While Func<TParameters, TResult> and Action<TParameters> are commonly used with lambda expressions, Expression<TDelegate> provides more advanced capabilities for scenarios where code analysis or manipulation is required.