Anonymous Method In C# (With Examples)

Last updated on July 18th, 2023 at 02:17 am

An anonymous method in C# is a method that doesn’t have a name. You can create an anonymous method using the delegate keyword and assign it to a variable of delegate type.

In this article, We will discuss about the Anonymous method with multiple examples.

What is Anonymous Method in C#?

An anonymous method in C# is a method without a name or return type. It consists only of the method body, which is a code block. It can be passed as a delegate parameter. The return type is automatically determined from the return statement within the method body.

Here are some simple points to understand:

• You can create an anonymous method using the delegate keyword with optional parameters. It can be assigned to a variable of the delegate type.
• Anonymous methods are inline statements or expressions that make the code easier to read and understand.
• They are useful when you want to directly associate an action with an event without creating a separate event handler function.
• Anonymous methods are useful for handling events.
• Variables or methods declared outside an anonymous method can be accessed inside it.
• Variables declared inside an anonymous method cannot be accessed outside of it.
• Anonymous methods can be passed as parameters to other methods or functions.

Syntax:

The following is the syntax to declare an anonymous method in C#.

delegate(Parameters)
{
    // Code Here.
};

Example: Anonymous Method

Here is an example of an anonymous method in C#.

using System;

class Program
{
    delegate void GreetingDelegate(string name);

    static void Main()
    {
        // Create an instance of the delegate and assign an anonymous method to it
        GreetingDelegate greeting = delegate (string name)
        {
            Console.WriteLine("Hello, " + name + "!");
        };

        // Call the delegate like a regular method
        greeting("Shekh Ali");

        Console.ReadLine();
    }
}

Code Explanation: 

In this example, we create an anonymous method using the delegate keyword. The anonymous method takes a string parameter called name and prints a greeting message to the console using the given name. 

We assign this anonymous method to a delegate named greeting.

When we call the delegate greeting("Shekh Ali"), it invokes the anonymous method, passing in the name “Shekh Ali”. 

As a result, the output will be:

Hello, Shekh Ali!

Example 2: Anonymous method in C#

Here is another example of an anonymous method in C#.

using System;
namespace AnonymousMethodDemo
{
    class Program
    {
        // Declaring a delegate
        public delegate int MyDelegate(int num1, int num2);

        static void Main(string[] args)
        {
            // Instantiating the delegate using an anonymous method

         MyDelegate myDelegate = delegate (int num1, int num2)
         {
            return num1 + num2;
         };
            Console.WriteLine(myDelegate(10,20));
        }
    }
    // Output: 30
}

Limitations of the Anonymous Method:

The following are the few limitations of the Anonymous method:

• Anonymous methods cannot be used to the left of the “is” operator.
• Jump statements such as goto, break, and continue are not allowed within an anonymous method.
• An anonymous method cannot access ref or out parameters from an outer scope.
• Anonymous methods cannot access unsafe code.
• Overloading an anonymous method is not possible.
• Anonymous methods cannot be used as the target of a virtual method call.
• Anonymous methods cannot be used as iterators or async methods.
• Anonymous methods cannot be used with the async/await keywords.

Example 3: Anonymous method as an event handler

We will use an anonymous method to define an event handler in the given example. This event handler will execute a specific action when the user clicks the submit button on the window form.

using System;
using System.Windows.Forms;

namespace WindowsFormsApp1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
           
    private void Form1_Load(object sender, EventArgs e)
        {
            // Creating Click Event handler using an Anonymous method
            btnSubmit.Click += delegate(object obj,EventArgs arg)
            {
                MessageBox.Show(" Hello !", "Anonymous method example");
            };
        }
    }
}

When the button is clicked, action will be performed directly in response to the Click event using an anonymous method, as shown in the image below.

As expected, a message box displays a “Hello” message when clicking the submit button.

Example 4: Anonymous method in a lambda expression

Here is an example of using an anonymous method in a lambda expression with code comments:

using System;

class Program
{
    delegate int CalculationDelegate(int a, int b);

    static void Main()
    {
        // Create an instance of the delegate and assign an anonymous method using a lambda expression
        CalculationDelegate calculation = (a, b) =>
        {
            return a + b;
        };

        // Call the delegate like a regular method
        int result = calculation(5, 3);
        Console.WriteLine("The result is: " + result);

        Console.ReadLine();
    }
}

Code Explanation:

In this example, we use an anonymous method in a lambda expression to create an instance of a delegate named calculation. The anonymous method takes two integer parameters, a and b, and returns their sum.

When we call the delegate calculation(5, 3), it invokes the anonymous method with the values 5 and 3, which results in their sum. 

The output will be:

The result is: 8

Example 5: Anonymous method as a parameter

Here is an example of using an anonymous method as a parameter in C#:

using System;

class Program
{
    // Delegate definition
    delegate void ProcessDelegate(string message);

    // Method that takes a delegate as a parameter
    static void PerformAction(string message, ProcessDelegate action)
    {
        // Execute the delegate passed as a parameter
        action(message);
    }

    static void Main()
    {
        // Call PerformAction method and pass an anonymous method as a parameter
        PerformAction("Hello World!", delegate(string message)
        {
            Console.WriteLine("Message received: " + message);
        });

        Console.ReadLine();
    }
}

Output:

Message received: Hello World!

References: MSDN – Lambda expressions

FAQs:

Here are some frequently asked questions (FAQs) about anonymous methods in C#:

Recommended Articles:

• Generic Delegates in C# With Examples: Func, Action, and Predicate delegates
• C# Struct with [Examples]
• Understanding Class vs Struct vs Record in C# with examples
• Difference Between if-else and switch: A Side-by-Side Comparison of If-Else and Switch Case
• Singleton Design Pattern in C#: A Beginner’s Guide with Examples
• SOLID Design Principles in C#: A Complete Example
• C# Struct vs Class |Top 15+ Differences Between C# Struct and Class
• 10 Difference between interface and abstract class In C#
• Local vs Global Variables
• Constructors in C#: A Comprehensive Guide with Code Examples

• Author
• Recent Posts

Shekh Ali

Meet Sheikh Ali, a skilled Software engineer and passionate a blogger. He enjoys sharing his expertise in C#, Java, SQL, Design Patterns, and other related topics through his writing. When he's not coding, Sheikh Ali can often indulge in his passions for reading books and fitness training.

Latest posts by Shekh Ali (see all)

• C# 12 New Features in 2025: What’s New with .NET 8 - April 11, 2025
• Difference Between WCF and Web API with Examples: A Comprehensive Guide - March 27, 2025
• PUT vs PATCH vs POST in REST API: Key Differences Explained With Examples - March 23, 2025