Kā izmantot join operatoru Entity Framework?

Entity Framework (EF)-ā JOIN operators tiek īstenots, izmantojot LINQ metodes Join vai SelectMany, kā arī izmantojot navigācijas īpašības:

1. Izmantojot navigācijas īpašības: Tas ir visbiežāk izmantotais un ieteicamais veids, ja ir izveidotas attiecības starp entītijām. EF automātiski ģenerē SQL vaicājumus ar JOIN:

   // Piemērs: Saņemt visus pasūtījumus ar klienta informāciju
   var ordersWithCustomers = context.Orders
       .Where(o => o.Customer != null) // Pārbaude, vai klients eksistē
       .Select(o => new
       {
           OrderId = o.Id,
           OrderDate = o.OrderDate,
           CustomerName = o.Customer.Name
       })
       .ToList();
   

2. LINQ Join: Izmanto skaidrai divu kolekciju apvienošanai pēc atbilstošiem laukiem, līdzīgi SQL INNER JOIN:

   // Piemērs: Apvienot Orders un Customers
   var ordersAndCustomers = context.Orders
       .Join(context.Customers, // Otrā kolekcija
             order => order.CustomerId, // Pirmās kolekcijas atslēga
             customer => customer.Id, // Otrās kolekcijas atslēga
             (order, customer) => new // Apvienošanas rezultāts
             {
                 OrderId = order.Id,
                 OrderDate = order.OrderDate,
                 CustomerName = customer.Name
             })
       .ToList();
   

3. LINQ GroupJoin: Līdzīgs SQL LEFT JOIN, grupē otrās kolekcijas elementus katram pirmajam:

   // Piemērs: Saņemt visus klientus un viņu pasūtījumus
   var customersWithOrders = context.Customers
       .GroupJoin(context.Orders, // Apvienošanas kolekcija
                  customer => customer.Id, // Klienta atslēga
                  order => order.CustomerId, // Pasūtījuma atslēga
                  (customer, orders) => new // Grupēšanas rezultāts
                  {
                      CustomerName = customer.Name,
                      Orders = orders.Select(o => new { o.Id, o.OrderDate }).ToList()
                  })
       .ToList();
   

4. LINQ SelectMany: Izmanto CROSS JOIN imitācijai vai elementu kombināciju veidošanai no divām kolekcijām. Kopā ar Where var veikt INNER JOIN funkciju:

   // Piemērs: Saņemt visus klientu-pasutījumu pārus
   var crossJoinExample = context.Customers
       .SelectMany(customer => context.Orders, // Katram klientam pievieno visus pasūtījumus
                   (customer, order) => new // Rezultāts
                   {
                       CustomerName = customer.Name,
                       OrderId = order.Id
                   })
       .ToList();
   
   // Piemērs: Imite iekšējo savienojumu ar `SelectMany` un `Where`
   var innerJoinWithSelectMany = context.Customers
       .SelectMany(customer => context.Orders, // Katram klientam pievieno katru pasūtījumu
                   (customer, order) => new // Starpprodukts
                   {
                       Customer = customer,
                       Order = order
                   })
       .Where(pair => pair.Customer.Id == pair.Order.CustomerId) // Filtrē pēc atbilstības
       .Select(pair => new // Galarezultāts
               {
                   CustomerName = pair.Customer.Name,
                   OrderId = pair.Order.Id
               })
       .ToList();
   

Izvēle ir atkarīga no konkrētās uzdevuma un datu struktūras. Navigācijas īpašības ir ieteicamākais veids, kā strādāt ar attiecībām, kas jau ir definētas EF modelī. Skaidri Join un GroupJoin nodrošina lielāku elastību sarežģītāku kolekciju apvienošanas scenāriju gadījumā. SelectMany ir noderīgs neparastākos gadījumos.