Kako koristiti operator join u Entity Framework?

U Entity Framework (EF), operator JOIN se implementira putem kombinacije LINQ metoda Join ili SelectMany, kao i korišćenjem navigacionih svojstava.

1. Korišćenje navigacionih svojstava: Najčešći i preporučeni način, ako su entiteti povezani relacijama. EF automatski generiše SQL upite sa JOIN.

   // Primer: Dobijanje svih porudžbina sa informacijama o klijentu
   var ordersWithCustomers = context.Orders
       .Where(o => o.Customer != null) // Provera postojanja klijenta
       .Select(o => new
       {
           OrderId = o.Id,
           OrderDate = o.OrderDate,
           CustomerName = o.Customer.Name
       })
       .ToList();
   

2. LINQ Join: Koristi se za eksplicitno spajanje dve kolekcije po odgovarajućim poljima, slično SQL INNER JOIN.

   // Primer: Spajanje Orders i Customers
   var ordersAndCustomers = context.Orders
       .Join(context.Customers, // Druga kolekcija
             order => order.CustomerId, // Ključ iz prve kolekcije
             customer => customer.Id, // Ključ iz druge kolekcije
             (order, customer) => new // Rezultat spajanja
             {
                 OrderId = order.Id,
                 OrderDate = order.OrderDate,
                 CustomerName = customer.Name
             })
       .ToList();
   

3. LINQ GroupJoin: Slično SQL LEFT JOIN, grupiše elemente druge kolekcije za svaki element prve.

   // Primer: Dobijanje svih klijenata i njihovih porudžbina
   var customersWithOrders = context.Customers
       .GroupJoin(context.Orders, // Kolekcija za spajanje
                  customer => customer.Id, // Ključ klijenta
                  order => order.CustomerId, // Ključ porudžbine
                  (customer, orders) => new // Rezultat grupisanja
                  {
                      CustomerName = customer.Name,
                      Orders = orders.Select(o => new { o.Id, o.OrderDate }).ToList()
                  })
       .ToList();
   

4. LINQ SelectMany: Koristi se za simulaciju CROSS JOIN ili za kreiranje kombinacija elemenata iz dve kolekcije. U kombinaciji sa Where može funkcionisati kao INNER JOIN.

   // Primer: Dobijanje svih parova klijent-porudžbina
   var crossJoinExample = context.Customers
       .SelectMany(customer => context.Orders, // Svakom klijentu odgovaraju sve porudžbine
                   (customer, order) => new // Rezultat
                   {
                       CustomerName = customer.Name,
                       OrderId = order.Id
                   })
       .ToList();
   
   // Primer: Immitacija Inner Join sa SelectMany i Where
   var innerJoinWithSelectMany = context.Customers
       .SelectMany(customer => context.Orders, // Svakom klijentu odgovaraju sve porudžbine
                   (customer, order) => new // Preliminarni rezultat
                   {
                       Customer = customer,
                       Order = order
                   })
       .Where(pair => pair.Customer.Id == pair.Order.CustomerId) // Filtriranje po odgovarajućim ključevima
       .Select(pair => new // Krajnji rezultat
               {
                   CustomerName = pair.Customer.Name,
                   OrderId = pair.Order.Id
               })
       .ToList();
   

Izbor metode zavisi od konkretne zadatka i strukture podataka. Navigaciona svojstva su preferirani pristup za rad sa već definisanim odnosima u EF modelu. Eksplicitni Join i GroupJoin pružaju veću fleksibilnost za složenije scenarije spajanja kolekcija. SelectMany je koristan za neobičnije slučajeve.