Linq genişletme yöntemlerini kullanarak sol dış birleşimi nasıl gerçekleştirirsiniz?

Sol bir dış birleşim olduğu varsayılarak:

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 }

Aynı görevi uzantı yöntemlerini kullanarak nasıl ifade edebilirim? Örneğin

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

Bir (dış sol) bir tablonun birleştirme için Barbir tablo ile Fooilgili Foo.Foo_Id = Bar.Foo_Idlambda gösterimde:

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

Bu yöntem (uzantı) sözdizimini kullanarak sol dış birleşimler için de facto SO soru gibi göründüğü için, (en azından benim deneyimimde) daha yaygın olarak ne olduğunu şu anda seçili cevaba bir alternatif ekleyeceğini düşündüm sonra

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

Basit bir veri kümesi kullanarak farkı görüntülemek için (değerlerin kendilerine katıldığımızı varsayarak):

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    }    

Seçenek 2, tipik sol dış birleşim tanımı için doğrudur, ancak daha önce de belirttiğim gibi, veri setine bağlı olarak genellikle gereksiz karmaşıktır.

İki veri kümesinin birleştirilmesi için Grup Birleştirme yöntemi gerekli değildir.

İç birleşim:

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

Left Join için sadece DefaultIfEmpty () ekleyin

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

EF ve LINQ to SQL doğru SQL'e dönüşür. LINQ to Objects için dahili olarak Lookup kullandığından GroupJoin kullanarak katılmak daha iyidir . Ama DB sorgulamak o zaman GroupJoin atlama performans olarak AFAIK olduğunu.

Personlay benim için bu şekilde GroupJoin () ile karşılaştırıldığında daha okunabilir.

Aşağıdakiler gibi bir uzantı yöntemi oluşturabilirsiniz:

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

Ocelot20'nin cevabını iyileştirerek, dışarda sadece 0 veya 1 satır olmasını istediğiniz yerde bir masanız varsa, ancak birden fazla olabilir, birleştirilmiş tablonuzu sipariş etmeniz gerekir:

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

Aksi takdirde, birleştirmede hangi satırı elde edeceğiniz rastgele olacaktır (veya daha spesifik olarak, db hangisini ilk bulursa).

Marc Gravell'in cevabını bir uzatma yöntemine çevirerek aşağıdakileri yaptım.

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

Kabul edilen cevap işe yarar ve Linq to Objects için iyi olsa da, SQL sorgusu sadece düz bir Sol Dış Birleştirme değil beni uyandırdı.

Aşağıdaki kod, ifadeleri iletmenize ve bunları sorgunuza çağırmanıza izin veren LinkKit Project'e dayanır .

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

Aşağıdaki gibi kullanılabilir

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

Bunun kolay bir çözümü var

Seçiminizde .HasValue kullanın

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

Çok kolay, gruplaşmaya veya başka bir şeye gerek yok