Kaip naudoti join operatorių Entity Framework?

Entity Framework (EF)-je JOIN operatorius įgyvendinamas naudojant LINQ metodus Join arba SelectMany, taip pat naudojant navigacines savybes:

1. Naudojant navigacines savybes: Tai dažniausiai naudojamas ir rekomenduojamas būdas, jei yra nustatyti ryšiai tarp entitetų. EF automatiškai generuoja SQL užklausas su JOIN:

   // Pavyzdys: Gauti visus užsakymus su kliento informacija
   var ordersWithCustomers = context.Orders
       .Where(o => o.Customer != null) // Patikrinimas, ar klientas yra
       .Select(o => new
       {
           OrderId = o.Id,
           OrderDate = o.OrderDate,
           CustomerName = o.Customer.Name
       })
       .ToList();
   

2. LINQ Join: Naudojamas aiškiam dviejų kolekcijų sujungimui pagal atitinkančius laukus, panašiai kaip SQL INNER JOIN:

   // Pavyzdys: Sujungti Orders ir Customers
   var ordersAndCustomers = context.Orders
       .Join(context.Customers, // Antra kolekcija
             order => order.CustomerId, // Pirmos kolekcijos raktas
             customer => customer.Id, // Antros kolekcijos raktas
             (order, customer) => new // Sujungimo rezultatas
             {
                 OrderId = order.Id,
                 OrderDate = order.OrderDate,
                 CustomerName = customer.Name
             })
       .ToList();
   

3. LINQ GroupJoin: Panašus į SQL LEFT JOIN, grupuoja antros kolekcijos elementus kiekvienam pirmos:

   // Pavyzdys: Gauti visus klientus ir jų užsakymus
   var customersWithOrders = context.Customers
       .GroupJoin(context.Orders, // Sujungimo kolekcija
                  customer => customer.Id, // Kliento raktas
                  order => order.CustomerId, // Užsakymo raktas
                  (customer, orders) => new // Grupavimo rezultatas
                  {
                      CustomerName = customer.Name,
                      Orders = orders.Select(o => new { o.Id, o.OrderDate }).ToList()
                  })
       .ToList();
   

4. LINQ SelectMany: Naudojamas CROSS JOIN imitacijai arba elementų kombinacijų kūrimui iš dviejų kolekcijų. Su Where gali atlikti INNER JOIN funkciją:

   // Pavyzdys: Gauti visus klientų-užsakymų porų
   var crossJoinExample = context.Customers
       .SelectMany(customer => context.Orders, // Kiekvienam klientui priskirti visus užsakymus
                   (customer, order) => new // Rezultatas
                   {
                       CustomerName = customer.Name,
                       OrderId = order.Id
                   })
       .ToList();
   
   // Pavyzdys: Imituoti Inner Join su SelectMany ir Where
   var innerJoinWithSelectMany = context.Customers
       .SelectMany(customer => context.Orders, // Kiekvienam klientui priskirti kiekvieną užsakymą
                   (customer, order) => new // Tarpinis rezultatas
                   {
                       Customer = customer,
                       Order = order
                   })
       .Where(pair => pair.Customer.Id == pair.Order.CustomerId) // Filtruoti pagal atitikimą
       .Select(pair => new // Galutinis rezultatas
               {
                   CustomerName = pair.Customer.Name,
                   OrderId = pair.Order.Id
               })
       .ToList();
   

Pasirinkimas priklauso nuo konkrečios užduoties ir duomenų struktūros. Navigacinės savybės yra pageidaujamas būdas dirbti su ryšiais, kurie jau yra apibrėžti EF modelyje. Aiškūs Join ir GroupJoin suteikia didesnį lankstumą sudėtingiems kolekcijų sujungimo scenarijams. SelectMany naudingas neįprastesniais atvejais.