Comment effectuer une jointure externe gauche à l'aide des méthodes d'extension linq

En supposant que j'ai une jointure externe gauche en tant que telle:

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 }

Comment exprimer la même tâche en utilisant des méthodes d'extension? Par exemple

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

Pour un (extérieur gauche) se joignent d'une table Baravec une table Foosur Foo.Foo_Id = Bar.Foo_Idla notation lambda:

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

Étant donné que cela semble être la question de facto SO pour les jointures externes gauches à l'aide de la syntaxe de la méthode (extension), j'ai pensé ajouter une alternative à la réponse actuellement sélectionnée qui (dans mon expérience au moins) a été plus communément ce que je suis après

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

Pour afficher la différence à l'aide d'un simple ensemble de données (en supposant que nous nous joignons aux valeurs elles-mêmes):

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    }    

L'option 2 est fidèle à la définition typique de jointure externe gauche, mais comme je l'ai mentionné précédemment, elle est souvent inutilement complexe en fonction de l'ensemble de données.

La méthode Group Join n'est pas nécessaire pour réaliser la jonction de deux ensembles de données.

Jointure interne:

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

Pour la jointure gauche, ajoutez simplement DefaultIfEmpty ()

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

EF et LINQ to SQL se transforment correctement en SQL. Pour LINQ to Objects, il est préférable de se joindre à l'aide de GroupJoin car il utilise en interne la recherche . Mais si vous interrogez DB, le saut de GroupJoin est AFAIK comme performant.

Personlay pour moi de cette façon est plus lisible que GroupJoin (). SelectMany ()

Vous pouvez créer une méthode d'extension comme:

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

Améliorant la réponse d'Ocelot20, si vous avez une table qui vous reste à l'extérieur avec où vous voulez juste 0 ou 1 lignes, mais elle peut en avoir plusieurs, vous devez Commander votre table jointe:

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

Sinon, la ligne que vous obtenez dans la jointure sera aléatoire (ou plus précisément, selon la base de données qui se trouve en premier).

Transformer la réponse de Marc Gravell en une méthode d'extension, j'ai fait ce qui suit.

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

Bien que la réponse acceptée fonctionne et soit bonne pour Linq to Objects, cela m'a dérangé que la requête SQL ne soit pas simplement une jointure externe gauche droite.

Le code suivant s'appuie sur le projet LinkKit qui vous permet de passer des expressions et de les invoquer dans votre requête.

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

Il peut être utilisé comme suit

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

Il existe une solution simple à ce problème

Utilisez simplement .HasValue dans votre Select

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

Très facile, pas besoin de groupjoin ou autre chose