Jak používat operátor join v Entity Framework?

V Entity Framework (EF) je operátor JOIN implementován pomocí kombinace LINQ metod Join nebo SelectMany, stejně jako použitím navigačních vlastností.

1. Použití navigačních vlastností: Nejčastější a doporučený způsob, pokud jsou mezi entitami nastaveny vztahy. EF automaticky generuje SQL dotazy s JOIN.

   // Příklad: Získání všech objednávek s informacemi o zákazníkovi
   var ordersWithCustomers = context.Orders
       .Where(o => o.Customer != null) // Kontrola existence zákazníka
       .Select(o => new
       {
           OrderId = o.Id,
           OrderDate = o.OrderDate,
           CustomerName = o.Customer.Name
       })
       .ToList();
   

2. LINQ Join: Používá se pro explicitní spojení dvou kolekcí podle odpovídajících polí, podobně jako SQL INNER JOIN.

   // Příklad: Spojení Orders a Customers
   var ordersAndCustomers = context.Orders
       .Join(context.Customers, // Druhá kolekce
             order => order.CustomerId, // Klíč z první kolekce
             customer => customer.Id, // Klíč z druhé kolekce
             (order, customer) => new // Výsledek spojení
             {
                 OrderId = order.Id,
                 OrderDate = order.OrderDate,
                 CustomerName = customer.Name
             })
       .ToList();
   

3. LINQ GroupJoin: Podobný SQL LEFT JOIN, seskupuje prvky druhé kolekce pro každý prvek první.

   // Příklad: Získání všech zákazníků a jejich objednávek
   var customersWithOrders = context.Customers
       .GroupJoin(context.Orders, // Kolekce pro spojení
                  customer => customer.Id, // Klíč zákazníka
                  order => order.CustomerId, // Klíč objednávky
                  (customer, orders) => new // Výsledek seskupení
                  {
                      CustomerName = customer.Name,
                      Orders = orders.Select(o => new { o.Id, o.OrderDate }).ToList()
                  })
       .ToList();
   

4. LINQ SelectMany: Používá se k napodobení CROSS JOIN nebo k vytváření kombinací prvků ze dvou kolekcí. V kombinaci s Where může fungovat jako INNER JOIN.

   // Příklad: Získání všech párů zákazník-objednávka
   var crossJoinExample = context.Customers
       .SelectMany(customer => context.Orders, // Každému zákazníkovi přiřadí všechny objednávky
                   (customer, order) => new // Výsledek
                   {
                       CustomerName = customer.Name,
                       OrderId = order.Id
                   })
       .ToList();
   
   // Příklad: Napodobení Inner Join s pomocí SelectMany a Where
   var innerJoinWithSelectMany = context.Customers
       .SelectMany(customer => context.Orders, // Každému zákazníkovi přiřadí každou objednávku
                   (customer, order) => new // Přechodný výsledek
                   {
                       Customer = customer,
                       Order = order
                   })
       .Where(pair => pair.Customer.Id == pair.Order.CustomerId) // Filtrace podle shodujících se klíčů
       .Select(pair => new // Konečný výsledek
               {
                   CustomerName = pair.Customer.Name,
                   OrderId = pair.Order.Id
               })
       .ToList();
   

Volba metody závisí na konkrétním úkolu a struktuře dat. Navigační vlastnosti jsou preferovaným přístupem pro práci se vztahy již definovanými v modelu EF. Explicitní Join a GroupJoin poskytují větší flexibilitu pro složitější scénáře spojování kolekcí. SelectMany je užitečný pro méně obvyklé případy.