Ako použiť operátor join v Entity Framework?

V Entity Framework (EF) sa operátor JOIN sa implementuje pomocou kombinácie LINQ metód Join alebo SelectMany, ako aj pomocou navigačných vlastností.

1. Použitie navigačných vlastností: Najbežnejší a odporúčaný spôsob, ak sú medzi entitami nastavené vzťahy. EF automaticky generuje SQL dotazy s JOIN.

   // Príklad: Získanie všetkých objednávok s informáciami o zákazníkovi
   var ordersWithCustomers = context.Orders
       .Where(o => o.Customer != null) // Kontrola existencie zákazníka
       .Select(o => new
       {
           OrderId = o.Id,
           OrderDate = o.OrderDate,
           CustomerName = o.Customer.Name
       })
       .ToList();
   

2. LINQ Join: Používa sa na explicitné spojenie dvoch kolekcií podľa zodpovedajúcich polí, podobne ako SQL INNER JOIN.

   // Príklad: Spojenie Orders a Customers
   var ordersAndCustomers = context.Orders
       .Join(context.Customers, // Druhá kolekcia
             order => order.CustomerId, // Kľúč z prvej kolekcie
             customer => customer.Id, // Kľúč z druhej kolekcie
             (order, customer) => new // Výsledok spojenia
             {
                 OrderId = order.Id,
                 OrderDate = order.OrderDate,
                 CustomerName = customer.Name
             })
       .ToList();
   

3. LINQ GroupJoin: Podobný SQL LEFT JOIN, grupuje prvky druhej kolekcie pre každý prvok prvej.

   // Príklad: Získanie všetkých zákazníkov a ich objednávok
   var customersWithOrders = context.Customers
       .GroupJoin(context.Orders, // Kolekcia na spojenie
                  customer => customer.Id, // Kľúč zákazníka
                  order => order.CustomerId, // Kľúč objednávky
                  (customer, orders) => new // Výsledok grupovania
                  {
                      CustomerName = customer.Name,
                      Orders = orders.Select(o => new { o.Id, o.OrderDate }).ToList()
                  })
       .ToList();
   

4. LINQ SelectMany: Používa sa na simuláciu CROSS JOIN alebo na vytváranie kombinácií prvkov z dvoch kolekcií. V kombinácii s Where môže fungovať ako INNER JOIN.

   // Príklad: Získanie všetkých párov klient-objednávka
   var crossJoinExample = context.Customers
       .SelectMany(customer => context.Orders, // Každému klientovi priradí všetky objednávky
                   (customer, order) => new // Výsledok
                   {
                       CustomerName = customer.Name,
                       OrderId = order.Id
                   })
       .ToList();
   
   // Príklad: Imitačné Inner Join s pomocou SelectMany a Where
   var innerJoinWithSelectMany = context.Customers
       .SelectMany(customer => context.Orders, // Každému klientovi priradí každú objednávku
                   (customer, order) => new // Prechodný výsledok
                   {
                       Customer = customer,
                       Order = order
                   })
       .Where(pair => pair.Customer.Id == pair.Order.CustomerId) // Filtrácia podľa zodpovedajúcich kľúčov
       .Select(pair => new // Konečný výsledok
               {
                   CustomerName = pair.Customer.Name,
                   OrderId = pair.Order.Id
               })
       .ToList();
   

Výber metódy závisí od konkrétneho úlohy a štruktúry dát. Navigačné vlastnosti sú preferovaným prístupom pre prácu s už definovanými vzťahmi v EF modeli. Explicitné Join a GroupJoin poskytujú väčšiu flexibilitu pre zložitejšie scenáre spájania kolekcií. SelectMany je užitočný pre menej štandardné prípady.