Ինչպես օգտագործել join օպերատորը Entity Framework-ում։

Entity Framework (EF)-ում JOIN օպերատորը իրականացնում է LINQ մեթոդների Join կամ SelectMany համադրությամբ, ինչպես նաև նավիգացիոն հատկությունների օգտագործմամբ:

1. Նավիգացիոն հատկությունների օգտագործում: Ամենատարածված և խորհուրդ տրվող մեթոդը, եթե միջնորդական հարաբերություններ են սահմանված։ EF- ն ավտոմատ կերպով գեներացնում է SQL հարցումները JOIN-ով:

   // Օրինակ՝ բոլոր պատվերների ստացումը հաճախորդի տեղեկություններով
   var ordersWithCustomers = context.Orders
       .Where(o => o.Customer != null) // Հաստատում հաճախորդի գոյությունը
       .Select(o => new
       {
           OrderId = o.Id,
           OrderDate = o.OrderDate,
           CustomerName = o.Customer.Name
       })
       .ToList();
   

2. LINQ Join: Օգտագործվում է երկու հավաքածուների հստակ միացման համար՝ համընկնող դաշտերով, նման SQL INNER JOIN-ի:

   // Օրինակ՝ Orders և Customers միացում
   var ordersAndCustomers = context.Orders
       .Join(context.Customers, // Երկրորդ հավաքածուն
             order => order.CustomerId, // Առաջին հավաքածուի բանալի
             customer => customer.Id, // Երկրորդ հավաքածուի բանալի
             (order, customer) => new // Միացման արդյունք
             {
                 OrderId = order.Id,
                 OrderDate = order.OrderDate,
                 CustomerName = customer.Name
             })
       .ToList();
   

3. LINQ GroupJoin: Նման է SQL LEFT JOIN-ին, խմբավորում է երկրորդ հավաքածուի տարրերը յուրաքանչյուր առաջինի համար:

   // Օրինակ՝ բոլոր հաճախորդների և նրանց պատվերների ստացումը
   var customersWithOrders = context.Customers
       .GroupJoin(context.Orders, // Միացման հավաքածու
                  customer => customer.Id, // Հաճախորդի բանալի
                  order => order.CustomerId, // Պատվերի բանալի
                  (customer, orders) => new // Խմբավորման արդյունք
                  {
                      CustomerName = customer.Name,
                      Orders = orders.Select(o => new { o.Id, o.OrderDate }).ToList()
                  })
       .ToList();
   

4. LINQ SelectMany: Օգտագործվում է CROSS JOIN-ի իմիտացիայի կամ տարրերի համադրությունների ստեղծման համար երկու հավաքածուներից։ Where-ի հետ համատեղ կարող է կատարել INNER JOIN-ի գործառույթ:

   // Օրինակ՝ բոլոր հաճախորդ-պատվեր զույգերի ստացում
   var crossJoinExample = context.Customers
       .SelectMany(customer => context.Orders, // Ամեն հաճախորդի համար բոլոր պատվերները
                   (customer, order) => new // Արդյունք
                   {
                       CustomerName = customer.Name,
                       OrderId = order.Id
                   })
       .ToList();
   
   // Օրինակ՝ Inner Join-ի իմիտացիա SelectMany և Where-ով
   var innerJoinWithSelectMany = context.Customers
       .SelectMany(customer => context.Orders, // Ամեն հաճախորդի համար բոլոր պատվերները
                   (customer, order) => new // Միջնորդական արդյունք
                   {
                       Customer = customer,
                       Order = order
                   })
       .Where(pair => pair.Customer.Id == pair.Order.CustomerId) // Բանալի համընկնումով ֆիլտրում
       .Select(pair => new // Վերջնական արդյունք
               {
                   CustomerName = pair.Customer.Name,
                   OrderId = pair.Order.Id
               })
       .ToList();
   

Ընտրությունը կախված է կոնկրետ խնդիրից և տվյալների կառուցվածքից։ Նավիգացիոն հատկությունները նախընտրելի են հարաբերությունների աշխատանքի համար, որոնք արդեն սահմանված են EF մոդելում։ Յստակ Join և GroupJoin-ը տրամադրում են ավելի մեծ ճկունություն բարդ հավաքածուների միացման համար։ SelectMany-ը օգտակար է ավելի անսովոր դեպքերում։