Come si esegue un join esterno sinistro utilizzando metodi di estensione LINQ

Question

Supponendo che ho un join esterno sinistro in quanto tale:

from f in Foo 
join b in Bar on f.Foo_Id equals b.Foo_Id into g 
from result in g.DefaultIfEmpty() 
select new { Foo = f, Bar = result } 

Come dovrei esprimere la stessa operazione utilizzando metodi di estensione? Per esempio.

Foo.GroupJoin(Bar, f => f.Foo_Id, b => b.Foo_Id, (f,b) => ???) 
    .Select(???) 

Answer 1

var qry = Foo.GroupJoin(
      Bar, 
      foo => foo.Foo_Id, 
      bar => bar.Foo_Id, 
      (x,y) => new { Foo = x, Bars = y }) 
    .SelectMany(
      x => x.Bars.DefaultIfEmpty(), 
      (x,y) => new { Foo=x.Foo, Bar=y}); 

Answer 2

È possibile creare metodo di estensione come:

public static IEnumerable<TResult> LeftOuterJoin<TSource, TInner, TKey, TResult>(this IEnumerable<TSource> source, IEnumerable<TInner> other, Func<TSource, TKey> func, Func<TInner, TKey> innerkey, Func<TSource, TInner, TResult> res) 
    { 
     return from f in source 
       join b in other on func.Invoke(f) equals innerkey.Invoke(b) into g 
       from result in g.DefaultIfEmpty() 
       select res.Invoke(f, result); 
    } 

Answer 3

Dal momento che questo sembra essere il fatto domanda SO per esterno sinistro si unisce con il metodo (estensione) della sintassi, ho pensato che sarebbe aggiungi un'alternativa alla risposta attualmente selezionata che (almeno nella mia esperienza) è stata più comunemente quella che sto cercando

// Option 1: Expecting either 0 or 1 matches from the "Right" 
// table (Bars in this case): 
var qry = Foos.GroupJoin(
      Bars, 
      foo => foo.Foo_Id, 
      bar => bar.Foo_Id, 
      (f,bs) => new { Foo = f, Bar = bs.SingleOrDefault() }); 

// Option 2: Expecting either 0 or more matches from the "Right" table 
// (courtesy of currently selected answer): 
var qry = Foos.GroupJoin(
        Bars, 
        foo => foo.Foo_Id, 
        bar => bar.Foo_Id, 
        (f,bs) => new { Foo = f, Bars = bs }) 
       .SelectMany(
        fooBars => fooBars.Bars.DefaultIfEmpty(), 
        (x,y) => new { Foo = x.Foo, Bar = y }); 

Per visualizzare la differenza usando un set di dati semplice (assumendo che ci stiamo unendo i valori stessi):

List<int> tableA = new List<int> { 1, 2, 3 }; 
List<int?> tableB = new List<int?> { 3, 4, 5 }; 

// Result using both Option 1 and 2. Option 1 would be a better choice 
// if we didn't expect multiple matches in tableB. 
{ A = 1, B = null } 
{ A = 2, B = null } 
{ A = 3, B = 3 } 

List<int> tableA = new List<int> { 1, 2, 3 }; 
List<int?> tableB = new List<int?> { 3, 3, 4 }; 

// Result using Option 1 would be that an exception gets thrown on 
// SingleOrDefault(), but if we use FirstOrDefault() instead to illustrate: 
{ A = 1, B = null } 
{ A = 2, B = null } 
{ A = 3, B = 3 } // Misleading, we had multiple matches. 
        // Which 3 should get selected (not arbitrarily the first)?. 

// Result using Option 2: 
{ A = 1, B = null } 
{ A = 2, B = null } 
{ A = 3, B = 3 } 
{ A = 3, B = 3 }  

Opzione 2 è fedele alla tipica join esterno sinistro definizione, ma come ho detto prima è spesso inutilmente complesse a seconda del set di dati.

Answer 4

Non è necessario unire un metodo per unire due insiemi di dati.

Inner Join:

var qry = Foos.SelectMany 
      (
       foo => Bars.Where (bar => foo.Foo_id == bar.Foo_id), 
       (foo, bar) => new 
        { 
        Foo = foo, 
        Bar = bar 
        } 
      ); 

Per LEFT JOIN Just Add DefaultIfEmpty()

var qry = Foos.SelectMany 
      (
       foo => Bars.Where (bar => foo.Foo_id == bar.Foo_id).DefaultIfEmpty(), 
       (foo, bar) => new 
        { 
        Foo = foo, 
        Bar = bar 
        } 
      ); 

EF trasforma correttamente a SQL. Per LINQ agli oggetti è preferibile unirsi a GroupJoin poiché utilizza internamente la funzione di ricerca, ma se si sta eseguendo una query su DB, saltare di GroupJoin è AFAIK come performante.

Personlay per me in questo modo è più leggibile rispetto al GroupJoin(). SelectMany()

Answer 5

migliorando la risposta di Ocelot20, se si dispone di una tabella si è lasciato esterno unisce con cui si desidera solo 0 o 1 righe fuori di esso, ma potrebbe avere più, è necessario ordinare la vostra tabella unita:

var qry = Foos.GroupJoin(
     Bars.OrderByDescending(b => b.Id), 
     foo => foo.Foo_Id, 
     bar => bar.Foo_Id, 
     (f, bs) => new { Foo = f, Bar = bs.FirstOrDefault() }); 

Altrimenti quale riga si ottiene nel join sta per essere casuale (o più precisamente, a seconda di quale il db accade di trovare prima).