Archive

Archive for the ‘Lenguajes’ Category

Expresiones Lambda

Buenos Días a todos

En esta ocasión veremos cómo simplificarnos la vida o mejor dicho como escribir menos y obtener los mismos resultados (la mayoría de las veces se mejoran los resultados)

Sin más preámbulo comenzaremos explicando que son las expresiones lambda:

Es una función anónima que puede contener expresiones y funciones y se puede utilizar para crear delegados o tipos de arboles de expresión.

Todas las expresiones lambda utilizan el operador lambda => que se lee “va a”1

La siguiente expresión X => X * X Se lee X va a X veces a X

Si ponemos un numero quedaría X => X * 5 y se lee X va a 5 veces a X

 El lado izquierdo del operador lambda especifica los parámetros de entrada (si es que existe alguno), mientras que el lado derecho contiene el bloque de expresiones o instrucciones.

 Ahora ya que sabemos cómo está formada una expresión lambda vamos a ver algunos tipos

Lambda de Expresión

(parametro) => Expresion           // Expresion Expliplicita

() => Mimetodo();                   // Expresion sin parametros de entrada

(int x) => x + 1;                  // Expresion Expliplicita

(int x,string y) => s.Length > x;

(x,y) => x + y;                     // Expresion Implicita

x => x + 1;      

 Lambda de instrucción

(parametro) => {Declaracion;}      // Expresion Expliplicita

 delegate void PruebaDelegada(string s);

PruebaDelegada miPrue = n =>

{string s = n + ” ” + “World”; Console.WriteLine(s); };

myDel(“Hello”);

Nota: Una expresión lambda de instrucción puede contener cualquier numero de instrucciones, pero ya en la realidad de la practica generalmente no hay mas de dos o tres.

Lambda con operadores estándar de consulta

 (int x,string y) => s.Length >= x;

Nota: no confundir el operador lambda(=>) con el “>=” mayor igua que

(int x,string y) => s.Length <= x;

 (int x,string y) => s.Length == x;

 (int x,string y) => s.Length % 2 == 1;  

Deducción de tipos con Lambda

Usuario.Where(parametro => Expresion);

Usuario.Where(n => n.Nombre == “John”);

Reglas para expresiones lambda

  • La lambda debe contener el mismo número de parámetros que el tipo delegado.
  • Cada parámetro de entrada en la lambda se debe poder convertir implícitamente a su parámetro de delegado correspondiente.
  • El valor devuelto de la lambda (si existe) se debe poder convertir implícitamente al tipo de valor devuelto del delegado.
  • Una variable que se captura no será eliminada por el recolector de elementos no utilizados hasta que el delegado que hace referencia a ella quede fuera del ámbito.
  • Las variables introducidas dentro de una expresión lambda no son visibles en el método externo.
  • Una expresión lambda no puede capturar directamente un parámetro ref o out desde un método que la englobe.
  • Una instrucción return en una expresión lambda no hace que el método que la engloba vuelva.
  • Una expresión lambda no puede contener una instrucción goto, una instrucción break o una instrucción continue cuyo destino esté fuera del cuerpo o en el cuerpo de una función anónima contenida.

 

1http://msdn.microsoft.com/es-es/library/bb397687.aspx

Espero que les sirva de referencia en su aprendisaje de expresiones Lambda