Jak wykonać LEFT outer join używając metod linq extension

Ponieważ wydaje się to być de facto tak pytanie dla lewych złączy zewnętrznych przy użyciu składni metody (rozszerzenia), pomyślałem, że dodam alternatywę dla aktualnie wybranej odpowiedzi, która (przynajmniej z mojego doświadczenia) była częściej tym, czego szukam

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

Aby wyświetlić różnicę za pomocą prostego zbioru danych (zakładając, że łączymy się na samych wartościach):

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    }    

Opcja 2 jest zgodna z typową definicją LEFT outer join, ale jak wspomniałem wcześniej jest często niepotrzebnie skomplikowane w zależności od zbioru danych.

Metoda łączenia grup jest zbędna do osiągnięcia połączenia dwóch zestawów danych.

Inner Join:

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

Dla LEFT Join wystarczy dodać DefaultIfEmpty ()

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

EF poprawnie przekształca się w SQL. Dla LINQ to objects lepiej jest dołączyć używając GroupJoin, ponieważ wewnętrznie używa Lookup, ale jeśli odpytywasz DB to Pomijanie GroupJoin jest AFAIK jako performant.

Personlay dla mnie ten sposób jest bardziej czytelny w porównaniu do GroupJoin ().SelectMany ()

Możesz utworzyć metodę rozszerzenia typu:

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

Poprawa na Ocelot20 ' s odpowiedź, jeśli masz tabelę, którą zostawiasz na zewnątrz, gdzie chcesz tylko 0 LUB 1 wiersz z niego, ale może mieć wiele, musisz zamówić połączoną tabelę:

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

W Przeciwnym Razie, który wiersz otrzymasz w połączeniu, będzie losowy(a dokładniej, w zależności od tego, który db znajdzie PIERWSZY).

Przekształcając odpowiedź marca Gravella w metodę rozszerzenia, zrobiłem następujące rzeczy.

internal static IEnumerable<Tuple<TLeft, TRight>> LeftJoin<TLeft, TRight, TKey>(
    this IEnumerable<TLeft> left,
    IEnumerable<TRight> right,
    Func<TLeft, TKey> selectKeyLeft,
    Func<TRight, TKey> selectKeyRight,
    TRight defaultRight = default(TRight),
    IEqualityComparer<TKey> cmp = null)
{
    return left.GroupJoin(
            right,
            selectKeyLeft,
            selectKeyRight,
            (x, y) => new Tuple<TLeft, IEnumerable<TRight>>(x, y),
            cmp ?? EqualityComparer<TKey>.Default)
        .SelectMany(
            x => x.Item2.DefaultIfEmpty(defaultRight),
            (x, y) => new Tuple<TLeft, TRight>(x.Item1, y));
}

Chociaż zaakceptowana odpowiedź działa i jest dobra dla Linq to Objects, to mnie wkurzyło, że zapytanie SQL nie jest tylko prostym lewym zewnętrznym łącznikiem.

Poniższy kod opiera się na projekcie LinkKit , który umożliwia przekazywanie wyrażeń i wywoływanie ich do zapytania.

static IQueryable<TResult> LeftOuterJoin<TSource,TInner, TKey, TResult>(
     this IQueryable<TSource> source, 
     IQueryable<TInner> inner, 
     Expression<Func<TSource,TKey>> sourceKey, 
     Expression<Func<TInner,TKey>> innerKey, 
     Expression<Func<TSource, TInner, TResult>> result
    ) {
    return from a in source.AsExpandable()
            join b in inner on sourceKey.Invoke(a) equals innerKey.Invoke(b) into c
            from d in c.DefaultIfEmpty()
            select result.Invoke(a,d);
}

Może być stosowany w następujący sposób

Table1.LeftOuterJoin(Table2, x => x.Key1, x => x.Key2, (x,y) => new { x,y});