.NET 10.0'daki yenilikler [24]: EF Core'daki LINQ RightJoin() ve LeftJoin() operatörleri

.NET 10.0, LINQ operatörlerini tanıtıyor LeftJoin() VE RightJoin() Entity Framework Core 10.0'da tüm veritabanı yönetim sistemleriyle de çalışır: Object Relational Mapper (ORM) bunları karşılık gelen SQL komutlarına çevirir; LeftJoin ve RightJoin ile ilgili sorunlara bakın.

Duyurudan sonra devamını okuyun

Dr. Holger Schwichtenberg, 53 tanınmış uzmanıyla çok sayıda orta ve büyük ölçekli şirketi danışmanlık, eğitim ve yazılım geliştirme yoluyla destekleyen www.IT-Visions.de uzman ağının teknik direktörüdür. Çok sayıda ulusal ve uluslararası konferansa katılımı, 90'dan fazla uzmanlık kitabı ve 1.500'den fazla uzmanlık makalesi sayesinde Holger Schwichtenberg, .NET ve web teknolojileri konusunda Almanya'nın en tanınmış uzmanlarından biridir.

Önceden, LINQ-to-Objects'te olduğu gibi zahmetli bir şekilde sol (dış) birleştirme ve sağ (dış) birleştirmeyi kullanmak zorundaydınız GroupJoin() VE SelectMany() birlikte DefaultIfEmpty() modülü.

Aşağıdaki bazı kod örnekleri kullanımını göstermektedir RightJoin() VE LeftJoin() Entity Framework Core 10.0 ile ilişkisel bir veritabanı kombinasyonu. Entity Framework'te ayrıca şunun sonucunu da alabilirsiniz: RightJoin() VE LeftJoin() aracılığıyla zaten ulaşıldı GroupJoin() VE SelectMany() ile DefaultIfEmpty(). Örnekler eski varyantla başlar ve ardından yeni varyantı gösterir.

Bu, .NET 11.0'daki bir yeniliktir: Dr. Holger Schwichtenberg ve diğer uzmanlar, 17 Kasım 2026'da BetterCode() .NET 11.0 çevrimiçi konferansında .NET SDK, C# 15.0 ve daha fazlasındaki geliştiriciler için değişiklikleri sunacaklar. Program yayına girene kadar indirimli kör kuş biletleri mevcuttur.

Aşağıdaki kod gösterir LeftJoin() “Uçuş” ve “Pilot” tablolarının bulunduğu bir veritabanında:

/// <summary>
 /// LeftJoin(): Suche alle Flüge, zu denen es keinen Piloten gibt
 /// </summary>
 public void EFC10_LeftJoin()
 {
  CUI.Demo(nameof(EFC10_LeftJoin));
  var ctx = new DA.WWWings.WwwingsV1EnContext();
 
  #region --------------- ALT
  CUI.H2("ALT: Suche alle Flüge, zu denen es keinen Piloten gibt via GroupJoin() und SelectMany()");
  var fluegeOhnePilotAlt = ctx.Flights
    .GroupJoin(
        ctx.Pilots,
        f => f.PilotPersonId,
        p => p.PersonId,
        (f, pilots) => new { Flight = f, Pilots = pilots.DefaultIfEmpty() }
    )
    .SelectMany(
        fp => fp.Pilots,
        (fp, p) => new
        {
         fp.Flight.FlightNo,
         fp.Flight.Departure,
         fp.Flight.Destination,
         fp.Flight.FlightDate,
         PilotId = fp.Flight.PilotPersonId == null ? "n/a" : fp.Flight.PilotPersonId.ToString(),
         GivenName = p.Employee.Person.GivenName,
         Surname = p.Employee.Person.Surname
        }
    )
    .Where(x => x.Surname == null)
    .Take(20)
    .ToList();
 
  Console.WriteLine("Gefundene Flüge: " + fluegeOhnePilotAlt.Count);
  foreach (var item in fluegeOhnePilotAlt)
  {
   Console.WriteLine($"{item.FlightNo} {item.Departure}->{item.Destination} am {item.FlightDate}: Pilot {item.PilotId} {item.GivenName} {item.Surname}");
  }
  #endregion
 
  #region --------------- NEU
  CUI.H2("NEU: Suche alle Flüge, zu denen es keinen Piloten gibt via LeftJoin()");
 
  var fluegeOhnePilotNeu = ctx.Flights
    .LeftJoin(
        ctx.Pilots,
        f => f.PilotPersonId,
        p => p.PersonId,
        (f, p) => new
        {
         f.FlightNo,
         f.Departure,
         f.Destination,
         f.FlightDate,
         PilotId = f.PilotPersonId == null ? "n/a" : f.PilotPersonId.ToString(),
         p.Employee.Person.GivenName,
         p.Employee.Person.Surname,
        }).Where(x => x.Surname == null).Take(20).ToList();
 
  Console.WriteLine("Gefundene Flüge: " + fluegeOhnePilotNeu.Count);
  foreach (var item in fluegeOhnePilotNeu)
  {
   Console.WriteLine($"{item.FlightNo} {item.Departure}->{item.Destination} am {item.FlightDate}: Pilot {item.PilotId} {item.GivenName} {item.Surname}");
  }
  #endregion
 
  #region --------------- Kontrolle
  CUI.H3("Zur Kontrolle:");
  // Zur Kontrolle:
  if (fluegeOhnePilotNeu.Count() > 0)
  {
   var f = ctx.Flights.Find(fluegeOhnePilotNeu[0].FlightNo);
   Console.WriteLine(f.ToNameValueString());
  }
  #endregion
 
 }

Bu LINQ komutundan LeftJoin() Aşağıdaki SQL komutu oluşturulur:

Duyurudan sonra devamını okuyun

SELECT TOP(@p) [f].[FlightNo], [f].[Departure], [f].[Destination], [f].[FlightDate], CASE
  WHEN [f].[Pilot_PersonID] IS NULL THEN 'n/a'
  ELSE COALESCE(CONVERT(varchar(11), [f].[Pilot_PersonID]), '')
END AS [PilotId], [p0].[GivenName], [p0].[Surname]
FROM [Operation].[Flight] AS [f]
LEFT JOIN [People].[Pilot] AS [p] ON [f].[Pilot_PersonID] = [p].[PersonID]
LEFT JOIN [People].[Employee] AS [e] ON [p].[PersonID] = [e].[PersonID]
LEFT JOIN [People].[Person] AS [p0] ON [e].[PersonID] = [p0].[PersonID]
WHERE [p0].[Surname] IS NULL

Aşağıdaki kod gösterir RightJoin() “Uçuş” ve “Pilot” tablolarının bulunduğu bir veritabanında:

/// <summary>
 /// Gibt zu den letzten drei angelegten Piloten alle Flüge aus
 /// </summary>
 public void EFC10_RightJoin()
 {
  CUI.Demo(nameof(EFC10_RightJoin));
  var ctx = new DA.WWWings.WwwingsV1EnContext();
 
  CUI.H2("Alt: Gibt zu den letzten drei angelegten Piloten alle Flüge aus via GroupJoin() und SelectMany()");
 
  var ctx2 = new DA.WWWings.WwwingsV1EnContext();
 
  #region --------------- ALT
  var pilotenMitFlugAlt = ctx.Pilots
    .OrderByDescending(x => x.PersonId)
    .Take(3)
    .GroupJoin(
        ctx.Flights,
        p => p.PersonId,
        f => f.PilotPersonId,
        (p, flights) => new { Pilot = p, Flights = flights.DefaultIfEmpty() }
    )
    .SelectMany(
        pf => pf.Flights,
        (pf, f) => new
        {
         PilotId = pf.Pilot.PersonId,
         pf.Pilot.Employee.Person.GivenName,
         pf.Pilot.Employee.Person.Surname,
         Flight = f,
         f.Departure,
         f.Destination,
        }
    )
    .OrderBy(x => x.PilotId)
    .ToList();
 
  foreach (var p in pilotenMitFlugAlt)
  {
   Console.WriteLine($"Pilot #{p.PilotId} {p.GivenName} {p.Surname} fliegt " + (p.Flight != null ? $"Flug #{p.Flight?.FlightNo} {p.Flight.Departure}->{p.Flight.Destination} am {p.Flight.FlightDate}" : "bisher keinen Flug"));
  }
  Console.WriteLine("Anzahl: " + pilotenMitFlugAlt.Count);
  #endregion
 
  #region --------------- NEU
  CUI.H2("Neu: Gibt zu den letzten drei angelegten Piloten alle Flüge aus via RightJoin()");
  var pilotenMitFlugNeu = ctx.Flights
    .RightJoin(
        ctx.Pilots.OrderByDescending(x => x.PersonId).Take(3),
        f => f.PilotPersonId,
        p => p.PersonId,
        (f, p) => new
        {
         PilotId = p.PersonId,
         p.Employee.Person.GivenName,
         p.Employee.Person.Surname,
         Flight = f,
         f.Departure,
         f.Destination,
        }).OrderBy(x => x.PilotId).ToList();
  
  foreach (var p in pilotenMitFlugNeu)
  {
   Console.WriteLine($"Pilot #{p.PilotId} {p.GivenName} {p.Surname} fliegt " + (p.Flight != null ? $"Flug #{p.Flight?.FlightNo} {p.Flight.Departure}->{p.Flight.Destination} am {p.Flight.FlightDate}" : "bisher keinen Flug"));
  }
  Console.WriteLine("Anzahl: " + pilotenMitFlugNeu.Count);
  #endregion
 
  #region --------------- Kontrolle
  CUI.H2("Nur zur Kontrolle: Gibt zu den letzten drei angelegten Piloten alle Flüge aus via Navigation Property");
 
  var pilotenMitFlug2 = ctx.Pilots.Include(p => p.Employee).ThenInclude(p => p.Person).Include(p => p.Flights).OrderByDescending(x => x.PersonId).Take(3).OrderBy(x => x.PersonId).ToList();
  int count = 0;
  foreach (Pilot p in pilotenMitFlug2)
  {
   if (p.Flights.Count == 0)
   {
    count++;
    Console.WriteLine($"Pilot #{p.PersonId} {p.Employee.Person.GivenName} {p.Employee.Person.Surname} fliegt bisher keinen Flug");
   }
   else
   {
    foreach (var f in p.Flights)
    {
     count++;
     Console.WriteLine($"Pilot #{p.PersonId} {p.Employee.Person.GivenName} {p.Employee.Person.Surname} fliegt Flug #{f.FlightNo} {f.Departure}->{f.Destination} am {f.FlightDate}");
   
    }
   }
  }
  Console.WriteLine("Anzahl: " + count);
  #endregion
 }

LINQ komutundan RightJoin() Aşağıdaki SQL komutu oluşturulur:

SELECT [p0].[PersonID] AS [PilotId], [p1].[GivenName], [p1].[Surname], [f].[FlightNo], [f].[Airline], [f].[Departure], [f].[Destination], [f].[FlightDate], [f].[FreeSeats], [f].[Memo], [f].[NonSmokingFlight], [f].[Pilot_PersonID], [f].[Seats], [f].[Timestamp]
FROM [Operation].[Flight] AS [f]
RIGHT JOIN (
  SELECT TOP(@p) [p].[PersonID]
  FROM [People].[Pilot] AS [p]
  ORDER BY [p].[PersonID] DESC
) AS [p0] ON [f].[Pilot_PersonID] = [p0].[PersonID]
INNER JOIN [People].[Employee] AS [e] ON [p0].[PersonID] = [e].[PersonID]
INNER JOIN [People].[Person] AS [p1] ON [e].[PersonID] = [p1].[PersonID]
ORDER BY [p0].[PersonID]

Şunu da açıkça belirtmek gerekir ki, yeni operatörler RightJoin() VE LeftJoin() önceden mevcut operatörler dahil Join() VE GroupJoin() Yalnızca nesne modelinde gezinme ilişkisi bulunmayan tabloları bağlamak için gereklidir.

Ayrıntılı bilgi yerine bunu nasıl yapabileceğinizi burada bulabilirsiniz RightJoin() Nesne modelinde bir gezinme ilişkisi mevcutsa, aynı çıktı sonucu Include() ulaşmak. Ancak bu durumda, pilot ve uçuş verilerini içeren basit bir liste elde edemezsiniz, bunun yerine nesnelerin hiyerarşisini, dolayısıyla iki iç içe geçmiş foreach döngüsünü elde edersiniz.

Aşağıdaki kod bir kullanır Include() navigasyon raporu aracılığıyla RightJoin():

CUI.H2("Gibt zu den letzten drei angelegten Piloten alle Flüge aus via Navigation Property");
 
 var pilotenMitFlug2 = ctx.Pilots.Include(p => p.Employee).ThenInclude(p => p.Person).Include(p => p.Flights).OrderByDescending(x => x.PersonId).Take(3).OrderBy(x => x.PersonId).ToList();
 
 foreach (Pilot p in pilotenMitFlug2)
 {
  if (p.Flights.Count == 0)
  {
   Console.WriteLine($"Pilot #{p.PersonId} {p.Employee.Person.GivenName} {p.Employee.Person.Surname} fliegt bisher keinen Flug");
  }
  else
  {
   foreach (var f in p.Flights)
   {
    Console.WriteLine($"Pilot #{p.PersonId} {p.Employee.Person.GivenName} {p.Employee.Person.Surname} fliegt Flug #{f.FlightNo} {f.Departure}->{f.Destination} am {f.FlightDate}");
   }
  }
 }

Entity Framework Core yalnızca iç birleştirmeleri gerçekleştirir:

SELECT [p0].[PersonID], [p0].[FlightHours], [p0].[FlightSchool], [p0].[LicenseDate], [p0].[LicenseType], [e].[PersonID], [e].[EmployeeNo], [e].[HireDate], [e].[Supervisor_PersonId], [p1].[PersonID], [p1].[Birthday], [p1].[City], [p1].[Country], [p1].[EMail], [p1].[GivenName], [p1].[Memo], [p1].[Photo], [p1].[Surname], [f].[FlightNo], [f].[Airline], [f].[Departure], [f].[Destination], [f].[FlightDate], [f].[FreeSeats], [f].[Memo], [f].[NonSmokingFlight], [f].[Pilot_PersonID], [f].[Seats], [f].[Timestamp]
FROM (
  SELECT TOP(@p) [p].[PersonID], [p].[FlightHours], [p].[FlightSchool], [p].[LicenseDate], [p].[LicenseType]
    FROM [People].[Pilot] AS [p]
    ORDER BY [p].[PersonID] DESC
   ) AS [p0]
INNER JOIN [People].[Employee] AS [e] ON [p0].[PersonID] = [e].[PersonID]
INNER JOIN [People].[Person] AS [p1] ON [e].[PersonID] = [p1].[PersonID]
LEFT JOIN [Operation].[Flight] AS [f] ON [p0].[PersonID] = [f].[Pilot_PersonID]
ORDER BY [p0].[PersonID], [e].[PersonID], [p1].[PersonID]

(Ben)

.NET 10.0'daki yenilikler [24]: EF Core'daki LINQ RightJoin() ve LeftJoin() operatörleri

Yorumlar

Bir yanıt yazın Yanıtı iptal et