Exploring Delegates and Lambdas

Using Lambdas with Delegates

Lambdas can be assigned to delegates directly. Example:

What is a Delegate?

A delegate is a type that holds references to methods with a specific signature. Delegates allow methods to be passed as parameters or assigned dynamically.

Example: Delegates are often used for callbacks and event handling.

Defining and Using Delegates

You can define a delegate using the delegate keyword. Example:

Key Point: Delegates provide a way to encapsulate methods.

using System;

class Program {
    // Define a delegate
    public delegate void PrintDelegate(string message);

    static void Main() {
        PrintDelegate print = PrintMessage; // Assign method to delegate
        print("Hello, Delegates!"); // Call the method via the delegate
    }

    static void PrintMessage(string message) {
        Console.WriteLine(message);
    }
}

What is a Lambda Expression?

A lambda expression is a concise way to represent an anonymous method in C#. It uses the syntax (parameters) => expression.

Example: (x, y) => x + y represents a method that adds two numbers.

Tip: Lambdas are often used with LINQ and delegates for brevity and clarity.

Using Lambdas with Delegates

Lambdas can be assigned to delegates directly. Example:

Key Point: Lambdas make your code more concise and readable.

using System;

class Program {
    public delegate int MathOperation(int x, int y);

    static void Main() {
        MathOperation add = (x, y) => x + y; // Lambda for addition
        Console.WriteLine("Result: " + add(10, 20)); // Outputs: Result: 30
    }
}

Multicast Delegates

A single delegate can reference multiple methods. All methods are invoked in order. Example:

using System;

class Program {
    public delegate void Notify(string message);

    static void Main() {
        Notify notify = PrintMessage;
        notify += LogMessage;

        notify("Hello, Multicast Delegates!"); // Calls both methods
    }

    static void PrintMessage(string message) {
        Console.WriteLine("Print: " + message);
    }

    static void LogMessage(string message) {
        Console.WriteLine("Log: " + message);
    }
}

Practice Challenge

Create a program that uses a delegate StringOperation to perform string manipulations like converting to uppercase and reversing a string. Example:

using System;

class Program {
    public delegate string StringOperation(string input);

    static void Main() {
        StringOperation operations = ToUpperCase;
        operations += ReverseString;

        string input = "Hello";
        foreach (var operation in operations.GetInvocationList()) {
            Console.WriteLine(((StringOperation)operation)(input));
        }
    }

    static string ToUpperCase(string input) {
        return input.ToUpper();
    }

    static string ReverseString(string input) {
        char[] chars = input.ToCharArray();
        Array.Reverse(chars);
        return new string(chars);
    }
}

Best Practices for Delegates and Lambdas

Here are some best practices:

• Use delegates to implement callbacks and event handling.
• Prefer lambda expressions for concise and clear code.
• Combine lambdas with LINQ for efficient data processing.
• Avoid overly complex lambdas to maintain readability.

Tip: Use meaningful parameter names in lambdas to improve code clarity.

Great Job!

Congratulations! You’ve learned how to use delegates and lambda expressions to write functional and event-driven code in C#. In the next lesson, we’ll explore reflection in C#, a powerful feature for runtime type analysis. Let’s keep coding!