ein reguläres Verfahren mit einer anonymen Methode in C#/LINQ

Question

Ersetzen habe ich eine LINQ-Abfrage, die wie folgt aussieht Klausel stattdessen.

Ich versuchte ...

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

... aber ich habe den folgenden Fehler:

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.

Wie kann ich "Lambda-ize" meine Frage?

---

aktualisieren

Das funktioniert auch nicht:

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

ich die folgende Fehlermeldung erhalten:

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

ich die join Klausel nicht geändert zu alles, also bin ich perplex.

Answer 1

Sie können Ihren Parametern in einem Lambda-Ausdruck Typen geben, aber Sie müssen andere Namen verwenden, da Sie in der Abfrage bereits f und b verwenden.

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

bearbeiten

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

wählen (f2, b2) => {f2.MissingProp = b2.MissingProp; return f2}

Answer 3

Schreiben Sie dies mit der Lambda-Syntax um.

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

Wenn Sie eine Erklärung dieser Syntax benötigen, lassen Sie es mich wissen.

Answer 4

denke ich icambron richtig ist, IMHO, desto besser lesbare Version ist dies:

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); 

Die from join select-Anweisungen für Abfragen werden, sollten sie nicht zum Mutieren des Inhalts einer Sequenz missbraucht werden.

EDIT: Hier ist eine weitere link bietet einige Einblicke, warum eine funktionale Form von ForEach ist keine gute Idee.

Answer 5

Wenn der Compiler nicht in der Lage ist, den korrekten Typ zu ermitteln, der an ein Lambda übergeben werden soll, können Sie den Typ natürlich selbst angeben.

sollte das hervorragend funktionieren:

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

Beachten Sie, dass, wie Sie schon bemerkt haben, können Sie nicht f und hoffen, wiederverwenden können, dass sie ihre Bedeutung behalten.Dies ist eine neue Methodensignatur mit neuen Parametern, daher müssen Sie einen eindeutigen Namen dafür verwenden.

Wenn Sie dies tun, stellen Sie fest, dass der Compiler nicht in der Lage ist, selbst herauszufinden, welcher Typ das erste Argument sein sollte, aber Sie können es wie oben angeben.