Métodos anónimos en .NET ( parte 1)

Algo que me ha gustado siempre de la plataforma .NET desde que comencé a aprender cosas de ella, es que te propone métodos para hacer las cosas más sencillas y ahorrarte tiempo que puedes ocupar en hacer otras cosas.

En la versión 2.0 de .NET, una de esas cosas que nos hace la vida más fácil a los que programamos son los métodos anónimos, cuya principal ventaja desde mi punto de vista es que nos permite ver inmediatamente lo que hace sin tener que redirigirnos a otras zonas de la clase que estamos desarrollando.

También sería todo mucho más fácil si el que trabaja es el compilador en vez de nosotros o por lo menos, que nos permita centrarnos más en que el programa haga lo que tiene que hacer.

Voy a poner un ejemplo, normalmente nosotros cuando queremos ejecutar una acción en respuesta a un evento, debemos declarar ese evento y “apuntar” al método que queremos ejecutar. Lo podemos ver a continuación con el siguiente código:

port.DataReceived += new System.IO.Ports.SerialDataReceivedEventHandler(port_DataReceived);

En esta línea de código correspondiente al evento que detecta la recepción de datos del puerto serie, estamos creando un manejador del evento “DataReceived”, indicándole donde está el código que debe ejecutar cuando se crea, en este caso el método “port_DataReceived”.

private void port_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
{
this.Invoke(new EventHandler(AdjuntarAlTextbox));
}

“port_DataReceived” solo va a ser ejecutado por el objeto “port” cuando lo crea oportuno y por nadie más, ya que ninguna otra parte del programa va a utilizarlo, a todos nos haría la vida mucho más fácil si lo que va a ejecutar el evento estuviera en el mismo sitio donde se indica “DataReceived” y encima el compilador fuera el que creara la declaración de ese evento.

Para ahorrarnos algunas líneas de código y permitir que el compilador nos ayude a programar vamos a usar un “tipo delegado”. Para ello hacemos uso de la palabra reservada “delegate” y entre llaves colocamos el código que queramos ejecutar, en el caso del ejemplo sería:

port.DataReceived += delegate { this.Invoke(new EventHandler(AdjuntarAlTextbox)); };

De esta manera nosotros no debemos indicar cuál es el manejador del evento que se debe usar, sino que el compilador será quien realice esta tarea. Además al codificar de esta manera sabemos inmediatamente que es lo que va a hacer el programa cuando reciba alguna información por el puerto serie.

No tenemos que indicar la declaración del evento y solo opcionalmente indicaremos los parámetros entre paréntesis a continuación de delegate. Esto es en el caso de necesitar el acceso a la información de algún objeto.

Como veis la palabra “delegate” nos permite hacer unas cuantas cosas muy útiles y sobre todo que nos aportan sencillez en muchos casos.

Otra cosa que podemos hacer es pasar como parámetro un método anónimo, en el caso de necesitar otra instancia del delegado que usamos.

Aquí dejo otro ejemplo:

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace metodosAnonimos
{
public delegate void Primero(string cadena);

class Program
{
static void Main(string[] args)
{
Primero a = delegate(string j)
{
Console.WriteLine(j);
};

a("fijate bien");

a = new Primero(Program.loquemepasen);

a("ves la diferencia");

Thread.Sleep(10000);
}

static void loquemepasen(string texto_pasado)
{
Console.WriteLine("Puedo hacer cualquier cosa y " + texto_pasado);
}
}
}

De todas formas, con los métodos anónimos como con todo, tampoco hay que usarlos a todas horas. Al igual que en muchas ocasiones aclaran el código y hacen que demos menos vueltas buscando lo que hace el programa, también pueden hacer que nos perdamos. Así que hay que usarlos cuando convenga y con moderación.

Para la segunda parte de este post trataremos una característica de C# 3.0 denominada “Expresiones Lambda”, que tienen relación con los método anónimos.

Saludetes[H]