Sustitución de un método regular con un método anónimo en C#/LINQ

Question

Tengo una consulta LINQ que tiene este aspecto:

public IEnumerable<Foo> SelectFooBars() 
{ 
    return 
     from 
      f in foos 
     join 
      b in bars 
      on f.BarId equals b.Id 
     select 
      AddMissingProp(f, b.MissingProp); 
} 

public void AddMissingProp(Foo foo, string missingProp) // substitute this with inline lambda 
{ 
    foo.MissingProp = missingProp; 
    return foo; 
} 

me gustaría deshacerse de AddMissingProp y utilizar alguna forma de lambda en mi select cláusula en su lugar.

intenté ...

... 
select 
    (f, b) => { f.MissingProp = b.MissingProp; return f } 

... pero tengo el siguiente error:

A local variable named 'f' cannot be declared in this scope because it would give a different meaning to 'f', which is already used in a 'parent or current' scope to denote something else.

¿Cómo puedo "lambda-ize" mi consulta?

---

actualización

Esto también no funciona:

... 
select 
    () => { f.MissingProp = b.MissingProp; return f } 

me sale el siguiente error:

The type of one of the expressions in the join clause is incorrect. Type inference failed in the call to 'Join'.

que no cambió la cláusula join en todo, así que estoy perplejo.

Answer 1

Puede dar tipos a sus parámetros en una expresión lambda pero necesita usar nombres diferentes ya que está usando f y b en la consulta.

(Foo f1, Bar b1) => ...

Editar

return 
(
    from 
     f in foos 
    join 
     b in bars 
     on f.BarId equals b.Id 
    select 
     new {f, b} 
).select(foobar => {foobar.f.BarId = foobar.b.Id; return foobar.f}); 

Answer 2

seleccione (f2, b2) => {f2.MissingProp = b2.MissingProp; return f2}

Answer 3

Vuelva a escribir esto con la sintaxis Lambda.

var vf2 = foos.Join(bars, f => f.id, b => b.id, (foo, bar) => { foo.MissingProp = bar.MissingProp; return foo; }); 

Si necesita una explicación de esta sintaxis, hágamelo saber.

Answer 4

creo icambron es correcto, en mi humilde opinión la mejor versión legible es la siguiente:

var fooBar = from 
       f in foos 
       join 
       b in bars 
       on f.BarId equals b.Id 
       select new {f,b}; 

    foreach(var x in fooBar) 
     x.f.MissingProp = x.b.MissingProp; 

    // EDIT due to comments: add this if you 
    // need IEnumerable<Foo> returned 
    return fooBar.Select(fb => fb.f); 

Las declaraciones se from join select para las consultas, no deben ser mal utilizados para mutar el contenido de una secuencia.

EDITAR: Aquí hay otra link que proporciona algunas ideas sobre por qué no es una buena idea usar una forma funcional de ForEach.

Answer 5

Si el compilador no puede inferir el tipo correcto para pasar a una lambda, puede especificar el tipo usted mismo.

Esto debería funcionar bien:

select 
    (Foo f2, b) => { f2.MissingProp = b.MissingProp; return f2; } 

Tenga en cuenta que como ya ha notado, no se puede volver a utilizar f y la esperanza de que retendrá su significado.Esta es una nueva firma de método, con nuevos parámetros, por lo que debe usar un nombre distinto para ella.

Cuando lo hace, observa que el compilador no puede determinar por sí mismo de qué tipo debe ser el primer argumento, pero puede especificarlo, como se indicó anteriormente.