LINQ do SQL: wiele złączeń na wielu kolumnach. Czy to możliwe?

W LINQ2SQL rzadko trzeba dołączać jawnie podczas używania złączy wewnętrznych.

Jeśli masz odpowiednie relacje z kluczami obcymi w bazie danych, automatycznie otrzymasz relację w LINQ designer (jeśli nie, możesz utworzyć relację ręcznie w designerze, chociaż naprawdę powinieneś mieć odpowiednie relacje w bazie danych)

Następnie możesz po prostu uzyskać dostęp do powiązanych tabel z "notacją kropkową"

var q = from child in context.Childs
        where child.Parent.col2 == 4
        select new
        {
            childCol1 = child.col1,
            parentCol1 = child.Parent.col1,
        };

Wygeneruje zapytanie

SELECT [t0].[col1] AS [childCol1], [t1].[col1] AS [parentCol1]
FROM [dbo].[Child] AS [t0]
INNER JOIN [dbo].[Parent] AS [t1] ON ([t1].[col1] = [t0].[col1]) AND ([t1].[col2] = [t0].[col2])
WHERE [t1].[col2] = @p0
-- @p0: Input Int (Size = -1; Prec = 0; Scale = 0) [4]
-- Context: SqlProvider(Sql2008) Model: AttributedMetaModel Build: 4.0.30319.1

W moim opinia jest o wiele bardziej czytelna i pozwala skoncentrować się na specjalnych warunkach, a nie na rzeczywistej mechanice połączenia.

Edit
Ma to oczywiście zastosowanie tylko wtedy,gdy chcesz dołączyć do naszego modelu bazy danych. Jeśli chcesz dołączyć "poza modelem" musisz uciekać się do ręcznych złączeń jak w odpowiedź z Quintin Robinson

Title_Authors jest spojrzeniem na dwie rzeczy, które łączą się w wyniki projektu i kontynuują łańcuchowanie

        DataClasses1DataContext db = new DataClasses1DataContext();
        var queryresults = from a in db.Authors                                          
                    join ba in db.Title_Authors                           
                    on a.Au_ID equals ba.Au_ID into idAuthor
                    from c in idAuthor
                    join t in db.Titles  
                    on c.ISBN equals t.ISBN 
                    select new { Author = a.Author1,Title= t.Title1 };

        foreach (var item in queryresults)
        {
            MessageBox.Show(item.Author);
            MessageBox.Show(item.Title);
            return;
        }

U można również użyć :

var query =
    from t1 in myTABLE1List 
    join t2 in myTABLE1List
      on new { ColA=t1.ColumnA, ColB=t1.ColumnB } equals new { ColA=t2.ColumnA, ColB=t2.ColumnB }
    join t3 in myTABLE1List
      on new {ColC=t2.ColumnA, ColD=t2.ColumnB } equals new { ColC=t3.ColumnA, ColD=t3.ColumnB }

Chciałbym podać inny przykład, w którym używa się wielu (3) złączeń.

 DataClasses1DataContext ctx = new DataClasses1DataContext();

        var Owners = ctx.OwnerMasters;
        var Category = ctx.CategoryMasters;
        var Status = ctx.StatusMasters;
        var Tasks = ctx.TaskMasters;

        var xyz = from t in Tasks
                  join c in Category
                  on t.TaskCategory equals c.CategoryID
                  join s in Status
                  on t.TaskStatus equals s.StatusID
                  join o in Owners
                  on t.TaskOwner equals o.OwnerID
                  select new
                  {
                      t.TaskID,
                      t.TaskShortDescription,
                      c.CategoryName,
                      s.StatusName,
                      o.OwnerName
                  };

Możesz również dołączyć, jeśli liczba kolumn nie jest taka sama w obu tabelach i możesz mapować wartość statyczną do kolumny tabeli

from t1 in Table1 
join t2 in Table2 
on new {X = t1.Column1, Y = 0 } on new {X = t2.Column1, Y = t2.Column2 }
select new {t1, t2}

Moim zdaniem jest to najprostszy sposób łączenia dwóch tabel z wieloma polami:

from a in Table1 join b in Table2    
       on (a.Field1.ToString() + "&" + a.Field2.ToString())     
       equals  (b.Field1.ToString() + "&" + b.Field2.ToString())  
     select a

Możesz napisać swoje zapytanie w ten sposób.

var query = from t1 in myTABLE1List // List<TABLE_1>
            join t2 in myTABLE1List
               on t1.ColumnA equals t2.ColumnA
               and t1.ColumnB equals t2.ColumnA

Jeśli chcesz porównać swoją kolumnę z wieloma kolumnami.