Anonymous Methods In C# Complete Guide

Introduction to Anonymous Methods in C#

Anonymous methods are used primarily when you need to provide the implementation of a delegate inline. Before lambda expressions were introduced in C# 3.0, anonymous methods were the way to inline delegate implementations.

Step 1: Setting Up a Delegate

First, let's define a delegate. A delegate is essentially a type-safe function pointer or a reference to a method.

public delegate void SampleDelegate(string message);

Step 2: Using an Anonymous Method with a Delegate

Now that we have a delegate, let's create an instance of it using an anonymous method.

using System;

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

    static void Main()
    {
        // Create an instance of the delegate using an anonymous method
        SampleDelegate sampleMethod = delegate (string message)
        {
            Console.WriteLine("Anonymous Method Called: " + message);
        };

        // Call the delegate
        sampleMethod("Hello, World!");
    }
}

In this example, delegate(string message) {...} is the anonymous method that matches the signature of our SampleDelegate. The code inside the curly braces {...} is the body of the anonymous method.

Step 3: Anonymous Methods with Parameters

Let's see how we can use anonymous methods with parameters. Suppose we have a delegate that takes an integer and returns a string describing whether the integer is even or odd.

using System;

class Program
{
    // Define a delegate
    public delegate string EvenOddDelegate(int number);

    static void Main()
    {
        // Create an instance of the delegate using an anonymous method
        EvenOddDelegate evenOddMethod = delegate (int number)
        {
            return (number % 2 == 0) ? "Even" : "Odd";
        };

        // Call the delegate
        Console.WriteLine("Number 5 is: " + evenOddMethod(5));
        Console.WriteLine("Number 4 is: " + evenOddMethod(4));
    }
}

In this example, the anonymous method checks if a number is even or odd and returns the corresponding string.

Step 4: Capturing Variables from the Enclosing Scope

Anonymous methods can capture local variables from the enclosing scope and use them within their body.

using System;

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

    static void Main()
    {
        string greeting = "Hello, Anonymous World!";

        // Create an instance of the delegate using an anonymous method
        PrintDelegate printMethod = delegate ()
        {
            Console.WriteLine(greeting);
        };

        // Call the delegate
        printMethod();
    }
}

Here, the anonymous method captures the greeting variable from the Main method and prints it.

Step 5: Anonymous Methods as Event Handlers

Anonymous methods can also be used as event handlers. Let's create a simple Button click event handler using an anonymous method.

using System;
using System.Windows.Forms;

class MainForm : Form
{
    private Button button1;

    public MainForm()
    {
        // Initialize and add the button to the form
        button1 = new Button() { Text = "Click Me", Dock = DockStyle.Top };
        this.Controls.Add(button1);

        // Attach an anonymous method to the button's Click event
        button1.Click += delegate (object sender, EventArgs e)
        {
            MessageBox.Show("Button was clicked!");
        };
    }

    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new MainForm());
    }
}

In this example, when the button is clicked, an anonymous method shows a message box saying "Button was clicked!".

Summary

• Definition: Anonymous methods allow you to declare methods inline without a name.
• Usage: They are typically used when assigning a method to a delegate or as event handlers.
• Syntax: Introduced before C# 3.0, the syntax uses the delegate keyword followed by the method signature and body.
• Advantages: Provides concise inline code where a full method might be overkill.
• Limitations: Less readable than named methods and less preferred if lambda expressions (C# 3.0+) or method group conversions (starting with C# 2.0) can be used instead.