Qual è il modo giusto per selezionare e combinare oggetti con LINQ?

Question

Ecco una situazione in cui mi imbatto frequentemente: ho oggetti Parent e Child e l'oggetto Child ha una proprietà Parent. Voglio eseguire una query che ottiene gli oggetti figlio e si unisce a ciascuno di l'oggetto padre corretto:

Dim db = New DataContextEx() 

get the children, along with the corresponding parent 
Dim Children = From x In db.ChildTable 
       Join y In db.ParentTable 
       On x.ParentId Equals y.Id 
       Execute x.Parent = y  <-- pseudocode 
       Select x 

La pseudo mostra quello che voglio realizzare: per restituire l'oggetto figlio x, ma con il codice dopo la (falso) Esegui dichiarazione eseguita. Posso pensare a molti modi per raggiungere l'obiettivo finale, ma tutti hanno molte più linee di codice e/o creazione di oggetti temporanei o funzioni che trovo poco eleganti. (Nota questa è la sintassi VB.NET, ma non è una domanda di sintassi VB, poiché AFAIK C# avrebbe lo stesso problema.)

Quindi quale sarebbe il modo più pulito per fare ciò che sto cercando di fare?

Modifica: le persone hanno chiesto quale ORM sto usando, ma questa è una domanda LINQ semplice e lineare; Non sto cercando di convertire questo in logica per essere eseguito sul server, voglio solo un po 'di zucchero sintattico per eseguire il lato client del codice dopo che la query è stata eseguita sul server.

Answer 1

Questi suggerimenti, in particolare @Paul's, sono stati molto utili, ma la mia versione finale è abbastanza diversa che ho intenzione di scrivere come la mia risposta.

I implementata la seguente funzione di estensione del tutto generale:

<Extension()> _ 
Public Function Apply(Of T)(ByVal Enumerable As IEnumerable(Of T), ByVal action As Action(Of T)) As IEnumerable(Of T) 
    For Each item In Enumerable 
     action(item) 
    Next 

    Return Enumerable 
End Function 

Questo è lo stesso come ForEach, eccetto che restituisce la sequenza in ingresso, e che il nome Applicare rende chiaro che ci sono lato effetti. Allora posso scrivere la mia domanda come:

Dim Children = (
      From x In db.ChildTable 
      Join y In db.ParentTable 
      On x.ParentId Equals y.Id 
      ). 
      Apply(Sub(item) item.x.Parent = item.y). 
      Select(Function(item) item.x) 

Sarebbe naturalmente meglio se ci fosse un modo per avere operatori di query personalizzati, quindi non avrebbe dovuto usare la sintassi lambda, ma anche così questo sembra molto pulito e riutilizzabile. Grazie ancora per tutto l'aiuto.

Answer 2

È possibile utilizzare un tipo anonimo durante la proiezione dei risultati. Esempio C#:

var items = from x In db.ChildTable 
      join y In db.ParentTable on x.ParentId equals y.Id 
      select new { Child =x , Parent=y }; 

Quindi assegnare le proprietà padre.

foreach(var item in items) 
{ 
    item.Child.Parent = item.Parent; 
} 

return items.Select(item => item.Child); 

Inoltre, si consiglia di utilizzare alcune soluzioni ORM per questo anziché il proprio.

Answer 3

Si può fare in questo modo:

aggiungere un metodo per fare la tua logica per classe di bambini che restituisce this o Me in VB

class Child 
{ 
    public Child GetWithAssignedParent(Parent y) 
    { 
     this.Parent = y; 
     return this; 
    } 
} 

uso questo metodo nella query di selezione a fare la logica e restituire le istanze aggiornate di classe del bambino:

var children = from x In db.ChildTable 
join y In db.ParentTable on x.ParentId equals y.Id 
select x.GetWithAssignedParent(y); 

o utilizzare Func <>

var children = from x in children 
join y in parents on x.ParentId equals y.Id 
select 
    new Func<Child>(() => 
    { 
     x.Parent = y; 
     return x; 
    }).Invoke(); 

Answer 4

Ecco probabilmente la soluzione più semplice:

var children = from x in db.ChildTable 
       join y in db.ParentTable 
       on x.ParentId equals y.Id 
       // Assign the Parent to the Child: 
       let parent = (x.Parent = y) // <-- Inline assignment (with a dummy variable "parent") 
       select x; 

responsabilità: questa ricerca ha assegnazione in linea e modifica dello stato ... entrambi i quali non sono considerati "best practice".
Tuttavia, è molto facile da leggere e comprendere, manutenibile e produce facilmente i risultati corretti, quindi direi che è un'ottima soluzione.

Inoltre, questo funzionerà solo in C#, perché VB.NET non dispone di assegnazione in linea.

Answer 5

Se si utilizza LinqToObjects, utilizzare questo codice per assegnare i genitori ai bambini.

ILookup<int, Child> lookup = children.ToLookup(c => c.ParentId) 

foreach(Parent p in parents) 
{ 
    foreach(Child c in lookup[p.Id]) 
    { 
    c.Parent = p; 
    } 
} 

---

Se stai usando LinqToSql, uso DataLoadOptions per caricare i record correlati.

---

Se si utilizza LinqToEntities, utilizzare .Include per caricare i record correlati.