C# Métodos anónimos

En C#, una función anónima es un método sin nombre que se puede definir y usar en el código.

Ya hemos mencionado que un delegado se utiliza para hacer referencia a métodos que tienen la misma firma que él. En otras palabras, puede utilizar un objeto delegado para invocar un método al que el delegado pueda hacer referencia.

Métodos anónimos (Anonymous methods)Proporcionan una técnica para pasar bloques de código como parámetros de delegado.

En los métodos anónimos no es necesario especificar el tipo de retorno; este se infiere de la instrucción return dentro del cuerpo del método.

Expresión lambda

Una expresión lambda es una sintaxis concisa para crear funciones anónimas. Se utilizan comúnmente en consultas LINQ y delegados.

Sintaxis

(parameters) => expression
// o 
(parameters) => { statement; }

Ejemplo

// Ejemplo: Definir un delegado mediante una expresión Lambda
Func<int, int, int> add = (a, b) => a + b;
Console.WriteLine(add(2, 3)); // Imprimir 5

// Ejemplo: usar expresiones Lambda para filtrar elementos de un array
int[] numbers = { 1, 2, 3, 4, 5 };
var evenNumbers = numbers.Where(n => n % 2 == 0);
foreach (var num in evenNumbers)
{
    Console.WriteLine(num); // Salida 2 4
}

Métodos anónimos

Los métodos anónimos se declaran mediante el uso de ladelegatepalabra clave para crear instancias de delegado.

Sintaxis

delegate(parameters) { statement; }

Por ejemplo:

delegate void NumberChanger(int n);
...
NumberChanger nc = delegate(int x)
{
    Console.WriteLine("Anonymous Method: {0}", x);
};

bloque de códigoConsole.WriteLine("Anonymous Method: {0}", x);es el cuerpo del método anónimo.

Un delegado puede invocarse mediante un método anónimo, o también mediante un método con nombre, es decir, pasando parámetros de método al objeto delegado.

Nota:El cuerpo del método anónimo requiere un;。

Por ejemplo:

nc(10);

Ejemplo

// Ejemplo: definir un delegado usando un método anónimo
Func<int, int, int> multiply = delegate (int a, int b)
{
    return a * b;
};
Console.WriteLine(multiply(2, 3)); // Imprimir 6

// Ejemplo: usar un método anónimo como controlador de eventos
Button button = new Button();
button.Click += delegate (object sender, EventArgs e)
{
    Console.WriteLine("Button clicked!");
};

Ejemplo

El siguiente ejemplo demuestra el concepto de los métodos anónimos:

Ejemplo

using System;

delegate void NumberChanger(int n);
namespace DelegateAppl
{
    class TestDelegate
    {
        static int num = 10;
        public static void AddNum(int p)
        {
            num += p;
            Console.WriteLine("Named Method: {0}", num);
        }

        public static void MultNum(int q)
        {
            num *= q;
            Console.WriteLine("Named Method: {0}", num);
        }

        static void Main(string[] args)
        {
            // Crear una instancia de delegado usando un método anónimo
            NumberChanger nc = delegate(int x)
            {
               Console.WriteLine("Anonymous Method: {0}", x);
            };
           
            // Usar método anónimo para invocar al delegado
            nc(10);

            // Instanciar un delegado mediante un método con nombre
            nc =  new NumberChanger(AddNum);
           
            // Usar método nombrado para invocar al delegado
            nc(5);

            // Instanciar el delegado usando otro método con nombre
            nc =  new NumberChanger(MultNum);
           
            // Usar método nombrado para invocar al delegado
            nc(2);
            Console.ReadKey();
        }
    }
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Anonymous Method: 10
Named Method: 15
Named Method: 30

En C# 2.0 y versiones posteriores, se introdujeron las expresiones lambda, que son una forma de sintaxis más concisa para escribir métodos anónimos.

Usando expresiones lambda:

Ejemplo

using System;

delegate void NumberChanger(int n);

namespace DelegateAppl
{
    class TestDelegate
    {
        static int num = 10;

        public static void AddNum(int p)
        {
            num += p;
            Console.WriteLine("Named Method: {0}", num);
        }

        public static void MultNum(int q)
        {
            num *= q;
            Console.WriteLine("Named Method: {0}", num);
        }

        static void Main(string[] args)
        {
            // Crear una instancia de delegado mediante una expresión lambda
            NumberChanger nc = x => Console.WriteLine($"Lambda Expression: {x}");

            // Usar una expresión lambda para invocar un delegado
            nc(10);

            // Instanciar un delegado mediante un método con nombre
            nc = new NumberChanger(AddNum);

            // Usar método nombrado para invocar al delegado
            nc(5);

            // Instanciar el delegado usando otro método con nombre
            nc = new NumberChanger(MultNum);

            // Usar método nombrado para invocar al delegado
            nc(2);

            Console.ReadKey();
        }
    }
}
Otras extensiones