Làm thế nào để bạn thực hiện nối ngoài trái bằng các phương thức mở rộng linq

Giả sử tôi có một tham gia bên ngoài bên trái như vậy:

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 }

Làm thế nào tôi có thể diễn tả cùng một nhiệm vụ bằng cách sử dụng các phương thức mở rộng? Ví dụ

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

Đối với một (bên trái bên ngoài) tham gia của một bảng Barvới một bảng Footrên Foo.Foo_Id = Bar.Foo_Idký hiệu 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});

Vì đây có vẻ là câu hỏi SO thực tế cho các phép nối ngoài trái bằng cách sử dụng cú pháp phương thức (phần mở rộng), tôi nghĩ rằng tôi sẽ thêm một câu trả lời cho câu trả lời hiện được chọn mà ít nhất là theo kinh nghiệm của tôi sau

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

Để hiển thị sự khác biệt bằng cách sử dụng một tập dữ liệu đơn giản (giả sử chúng ta đang tham gia vào chính các giá trị):

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    }    

Tùy chọn 2 đúng với định nghĩa nối ngoài bên trái điển hình, nhưng như tôi đã đề cập trước đó thường phức tạp không cần thiết tùy thuộc vào tập dữ liệu.

Phương pháp nhóm tham gia là không cần thiết để đạt được tham gia của hai bộ dữ liệu.

Tham gia nội bộ:

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

Đối với phần còn lại, chỉ cần thêm Default IfEmpty ()

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

EF và LINQ to SQL chuyển đổi chính xác thành SQL. Đối với LINQ to Object, việc tham gia bằng GroupJoin là không chính xác khi nó sử dụng Tra cứu nội bộ . Nhưng nếu bạn đang truy vấn DB thì bỏ qua GroupJoin là AFAIK với tư cách là người biểu diễn.

Personlay đối với tôi theo cách này dễ đọc hơn so với GroupJoin (). ChọnMany ()

Bạn có thể tạo phương thức mở rộng như:

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

Cải thiện câu trả lời của Ocelot20, nếu bạn có một bảng bạn còn lại bên ngoài tham gia với nơi bạn chỉ muốn 0 hoặc 1 hàng trong số đó, nhưng nó có thể có nhiều bảng, bạn cần phải đặt thứ tự bảng đã tham gia của mình:

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

Mặt khác, hàng nào bạn nhận được trong phép nối sẽ là ngẫu nhiên (hoặc cụ thể hơn, tùy theo trường hợp db xảy ra trước tiên).

Biến câu trả lời của Marc Gravell thành một phương pháp mở rộng, tôi đã làm như sau.

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

Trong khi câu trả lời được chấp nhận hoạt động và rất tốt cho Linq đối với các đối tượng, nó đã nói với tôi rằng truy vấn SQL không chỉ là một kết nối bên ngoài bên trái.

Đoạn mã sau dựa trên Dự án LinkKit cho phép bạn truyền biểu thức và gọi chúng vào truy vấn của bạn.

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

Nó có thể được sử dụng như sau

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

Có một giải pháp dễ dàng cho việc này

Chỉ cần sử dụng .HasValue trong Chọn của bạn

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

Rất dễ dàng, không cần tham gia nhóm hay bất cứ điều gì khác