Expresiones Lambda, inferencia de tipos, que palabras más raras. Esa fue mi primera
impresión cuando las escuche, sobre todo lo de inferencia de tipo, no entendía lo
que era una expresión Lambda y en la explicación decia que utiliza inferencia de
tipos, en fin, vamos a ver de qué se trata.
List<Persona>
personas = new List<Persona>() { new Persona{Nombre="Javier",Apellido="Saviola",Edad=25},
new Persona{Nombre="Enzo",Apellido="Francescoli",Edad=45}, new Persona{Nombre="Pablo",Apellido="Aimar",Edad=28}
};
IEnumerable<Persona> mayores= personas.Where(p => p.Edad > 25);
foreach (Persona item in mayores)
{
ObjectDumper.Write(item);
}
La primer cosa que nos llama la atención de este código es que River Plate
no tiene ídolos jóvenes, la segunda es la siguiente línea
IEnumerable<persona> mayores= personas.Where(p => p.Edad > 25);
Esto es justamtente una expresión Lambda utilizada como parámetro del método
Where, y es justo por eso que podemos entender su funcionamiento. Si vamos a la
firma del método vemos
public static IEnumerable<tsource>
Where<tsource>(this IEnumerable<tsource> source, Func<tsource,bool>
predicate); Ignoremos el primer parámetro que indica que es un
método de extensión, es el segundo el que nos interesa
Func<Tsource,bool> predicate El método espera una función
con dos parámetros, primero el mismo tipo de la colección (en este caso Persona),
y por otro lado un booleano (que será el criterio). Aquí es donde entra la inferencia
de tipos, ya que sabemos que el primer parámetro es un objeto Persona y el segundo
una expresión que retorna bool simplemente indicamos
p=>p.Edad>24 la primer p será el nombre que le damos al
primer parámetro (o sea que será el objeto persona) y el segundo la expresión, en
este caso evaluamos la edad. Eso es lo que significa inferencia de tipos, todo aquello
que se puede suponer (como que el primer parámetro será un objeto Persona) se supone
a favor de hacer más fácil el código y no tener que escribir un delegado para esto.
Destripando el código
Sin embargo, esto no es mágia, sino que el compilador crea el delegado por nostros,
echemos mano del Reflector y veamos qué onda
private void Test()
{
List<Persona> <>g__initLocal0 = new List();
Persona <>g__initLocal1 = new Persona();
<>g__initLocal1.Nombre = "Javier";
<>g__initLocal1.Apellido = "Saviola";
<>g__initLocal1.Edad = 0x19;
<>g__initLocal0.Add(<>g__initLocal1);
Persona <>g__initLocal2 = new Persona();
<>g__initLocal2.Nombre = "Enzo";
<>g__initLocal2.Apellido = "Francescoli";
<>g__initLocal2.Edad = 0x2d;
<>g__initLocal0.Add(<>g__initLocal2);
Persona <>g__initLocal3 = new Persona();
<>g__initLocal3.Nombre = "Pablo";
<>g__initLocal3.Apellido = "Aimar";
<>g__initLocal3.Edad = 0x1c;
<>g__initLocal0.Add(<>g__initLocal3);
List
personas = <>g__initLocal0;
IEnumerable
mayores = personas.Where(delegate (Persona p) { return (p.Edad
> 0x19); }).Select(delegate (Persona p) { return
p; });
foreach (Persona item in mayores)
{
ObjectDumper.Write(item);
}
}
Vemos en la línea que resalté que ha sido creado un delegado de la expresión
Lambda (de echo son dos hay otro para el método Select), esto no lo haremos en la
práctica (descompilar cada cosa que hacemos) pero es útil para entender cómo funcionan
las cosas. Hasta la próxima.
