Wie führe ich einen linken äußeren Join mit Linq-Erweiterungsmethoden durch?

Angenommen, ich habe eine linke äußere Verknüpfung als solche:

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 }

Wie würde ich dieselbe Aufgabe mit Erweiterungsmethoden ausdrücken? Z.B

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

Für A (links außen) verbindet eine Tabelle Barmit einem Tisch Fooauf Foo.Foo_Id = Bar.Foo_Idin Lambda Notation:

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

Da dies die De-facto-SO-Frage für Linksaußenverknüpfungen unter Verwendung der Methodensyntax (Erweiterungssyntax) zu sein scheint, dachte ich, ich würde eine Alternative zu der aktuell ausgewählten Antwort hinzufügen, die (zumindest nach meiner Erfahrung) häufiger das war, was ich bin nach dem

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

So zeigen Sie den Unterschied mithilfe eines einfachen Datensatzes an (vorausgesetzt, wir verbinden die Werte selbst):

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    }    

Option 2 entspricht der typischen linken äußeren Verknüpfungsdefinition, ist jedoch, wie bereits erwähnt, je nach Datensatz häufig unnötig komplex.

Die Gruppenverbindungsmethode ist nicht erforderlich, um die Verknüpfung zweier Datensätze zu erreichen.

Inner Join:

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

Für Left Join fügen Sie einfach DefaultIfEmpty () hinzu

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

EF und LINQ to SQL werden korrekt in SQL umgewandelt. Für LINQ to Objects ist es besser, mit GroupJoin beizutreten, da es intern Lookup verwendet . Wenn Sie jedoch DB abfragen, ist das Überspringen von GroupJoin AFAIK als Performant.

Personlay ist für mich auf diese Weise besser lesbar als GroupJoin (). SelectMany ()

Sie können eine Erweiterungsmethode erstellen wie:

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

Um die Antwort von Ocelot20 zu verbessern: Wenn Sie eine Tabelle haben, bei der Sie nur noch 0 oder 1 Zeilen davon haben möchten, die jedoch mehrere Zeilen enthalten können, müssen Sie Ihre verknüpfte Tabelle bestellen:

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

Andernfalls ist die Zeile, die Sie im Join erhalten, zufällig (oder genauer gesagt, je nachdem, was die Datenbank zuerst findet).

Als ich Marc Gravells Antwort in eine Erweiterungsmethode verwandelte, machte ich Folgendes.

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

Obwohl die akzeptierte Antwort funktioniert und für Linq to Objects gut ist, hat es mich gestört, dass die SQL-Abfrage nicht nur ein direkter Left Outer Join ist.

Der folgende Code basiert auf dem LinkKit-Projekt , mit dem Sie Ausdrücke übergeben und für Ihre Abfrage aufrufen können.

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

Es kann wie folgt verwendet werden

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

Hierfür gibt es eine einfache Lösung

Verwenden Sie einfach .HasValue in Ihrer Auswahl

.Select(s => new 
{
    FooName = s.Foo_Id.HasValue ? s.Foo.Name : "Default Value"
}

Sehr einfach, keine Notwendigkeit für Gruppenbeiträge oder irgendetwas anderes