Topic 10924 min readStructured Tutorial

Delegates and Events in C#: Understanding Anonymous Methods

Quick Answer

Anonymous methods in C# allow you to define inline delegate implementations without a separate method declaration. They simplify event handling and delegate usage by embedding the method body directly where the delegate is assigned, improving code readability and flexibility.

Learning Objectives

Explain the purpose of Anonymous Methods in a practical learning context.
Identify the main ideas, terms, and decisions involved in Anonymous Methods.
Apply Anonymous Methods in a simple real-world scenario or practice task.

Introduction to Anonymous Methods in C#

Delegates and events are fundamental to C# programming, enabling flexible and dynamic method invocation.

Anonymous methods provide a way to write inline delegate implementations without explicitly declaring a separate method.

Anonymous methods help keep your code concise and focused by embedding delegate logic directly where it's needed.

What Are Anonymous Methods?

Anonymous methods let you define a delegate's method body inline using the delegate keyword without naming the method.

They were introduced in C# 2.0 to simplify delegate usage and reduce boilerplate code.

Inline method definition without a separate method name
Can capture variables from the enclosing scope
Useful for short, one-off delegate implementations

Syntax of Anonymous Methods

The syntax uses the delegate keyword followed by a code block containing the method body.

Anonymous methods can be assigned to delegate variables or used directly in event subscriptions.

Basic syntax: delegate(parameters) { /* method body */ };
Parameters can be omitted if the delegate type has no parameters
Supports capturing local variables from the outer scope

Example: Assigning an Anonymous Method to a Delegate

Here is a simple example demonstrating an anonymous method assigned to a delegate.

Using Anonymous Methods with Events

Anonymous methods are commonly used to handle events without creating separate named methods.

This approach keeps event handling logic close to the event subscription, improving readability.

Subscribe to events using anonymous methods for concise handlers
Capture local variables to maintain state within the handler
Unsubscribe using the same anonymous method reference if needed

Advantages and Limitations

Anonymous methods reduce code clutter and improve maintainability for small delegate implementations.

However, they can make debugging harder if overused or used for complex logic.

Advantages:
- Inline definition reduces boilerplate
- Can capture outer variables (closures)
Limitations:
- Less readable for complex logic
- Cannot be reused like named methods

Practical Example

This example defines a delegate type and assigns an anonymous method that prints a message to the console.

This example shows subscribing to a button's Click event using an anonymous method that writes a message when the event is raised.

Examples

Anonymous Method Assigned to a Delegate

delegate void PrintMessage(string message);

PrintMessage printer = delegate(string msg) {
    Console.WriteLine(msg);
};

printer("Hello from anonymous method!");

This example defines a delegate type and assigns an anonymous method that prints a message to the console.

Using Anonymous Method for Event Handling

using System;

class Button {
    public event EventHandler Click;

    public void OnClick() {
        Click?.Invoke(this, EventArgs.Empty);
    }
}

class Program {
    static void Main() {
        Button button = new Button();

        button.Click += delegate(object sender, EventArgs e) {
            Console.WriteLine("Button clicked!");
        };

        button.OnClick();
    }
}

This example shows subscribing to a button's Click event using an anonymous method that writes a message when the event is raised.

Best Practices

Use anonymous methods for short, simple delegate implementations.
Prefer lambda expressions for more concise syntax when possible.
Avoid complex logic inside anonymous methods to maintain readability.
Capture only necessary variables to prevent unintended side effects.

Common Mistakes

Using anonymous methods for large or complex code blocks.
Forgetting to unsubscribe anonymous methods from events, leading to memory leaks.
Overusing anonymous methods when named methods would improve clarity.

Hands-on Exercise

Create an Anonymous Method Delegate

Define a delegate that takes an integer and prints its square using an anonymous method.

Expected output: For input 5, output should be '25'.

Hint: Use the delegate keyword to define the anonymous method inline.

Subscribe to an Event with an Anonymous Method

Create a simple event and subscribe to it using an anonymous method that prints a message when the event is triggered.

Expected output: When the event is raised, the message is printed to the console.

Hint: Use the += operator with an anonymous method for subscription.

Interview Questions

What is an anonymous method in C#?

Interview

An anonymous method is a method without a name defined inline using the delegate keyword, allowing you to assign method bodies directly to delegates or event handlers.

How do anonymous methods differ from lambda expressions?

Interview

Anonymous methods use the delegate keyword and can have multiple statements, while lambda expressions provide a more concise syntax and are preferred in modern C# for inline delegate implementations.

Can anonymous methods capture variables from the outer scope?

Interview

Yes, anonymous methods can capture and use variables from their enclosing scope, creating closures.