Om overeenkomende records uit de linkertabel en de rechtertabel in SQL weer te geven, is de linker outer join een soort join-bewerking die wordt gebruikt. In LINQ kan de left outer join worden uitgevoerd met behulp van de GroupJoin()- en SelectMany()-methoden. In dit artikel wordt uitgebreid ingegaan op het uitvoeren van left outer joins in LINQ met behulp van C#.
Hoe Left Outer Joins in LINQ uit te voeren met behulp van C#
Om een left outer join uit te voeren in LINQ, kunt u de methode GroupJoin() gebruiken om twee reeksen samen te voegen op basis van een gemeenschappelijke sleutel en vervolgens de methode SelectMany() gebruiken om het resultaat af te vlakken. Hier is een voorbeeld:
systeem gebruiken;
met behulp van System.Linq;
klasse programma
{
statische leegte Main ( )
{
var links = nieuw [ ] { 1 , 2 , 3 } ;
var rechts = nieuw [ ] { 2 , 3 , 4 } ;
var resultaat = links.GroupJoin (
rechts,
ik = > ik,
r = > R,
( ik, r ) = > nieuw { Links = l, Rechts = r.DefaultIfEmpty ( ) } )
.SelecteerVeel (
lr = > lr.Rechts.Select (
r = > nieuw { Links = lr.Links, Rechts = r } ) ) ;
voor elk ( var-item in resultaat )
{
Console.WriteLine ( '{0} {1}' , item.Links, item.Rechts ) ;
}
}
}
Deze code voert een left outer join uit op twee arrays links en rechts, en drukt het resultaat af naar de console. De methode GroupJoin() voert de join uit en de SelecteerVeel() methode wordt gebruikt om het resultaat af te vlakken. Ten slotte wordt het resultaat afgedrukt naar de console met behulp van een foreach-lus en de WriteLine()-functie:
Hier is nog een voorbeeld dat het gebruik demonstreert van het uitvoeren van weggelaten joins door de respectievelijke werknemersnamen en hun relevante afdelingen weer te geven. Aan elke medewerker van elke afdeling is een nummer toegewezen dat vervolgens wordt gebruikt om de relevante afdeling aan de betreffende medewerker te koppelen, hier is de volledige code ervoor:
systeem gebruiken;met behulp van System.Collections.Generic;
met behulp van System.Linq;
naamruimte YourNamespace
{
klasse programma
{
statische leegte Main ( snaar [ ] argumenten )
{
Lijst < Naam werknemer > werknemers = nieuwe lijst < Naam werknemer >
{
nieuwe Medewerkernaam { Idd = 1 , Naam = 'Zichzelf' , AfdelingsID = 1 } ,
nieuwe Medewerkernaam { Idd = 2 , Naam = 'John' , AfdelingsID = 2 } ,
nieuwe Medewerkernaam { Idd = 3 , Naam = 'Kevin' , AfdelingsID = 2 } ,
nieuwe Medewerkernaam { Idd = 4 , Naam = 'Bob' , AfdelingsID = 3 }
} ;
Lijst < Afdeling > afdelingen = nieuwe lijst < Afdeling >
{
nieuwe Afdeling { Idd = 1 , Naam = 'Inhoud schrijven' } ,
nieuwe Afdeling { Idd = 2 , Naam = 'Marketing' } ,
nieuwe Afdeling { Idd = 3 , Naam = 'Engineering' }
} ;
var query = from medewerkernaam in medewerkers
meedoen afdeling in afdelingen
op employeename.DepartmentId is gelijk aan department.Id in departmentGroup
van afdeling in afdelingGroup.DefaultIfEmpty ( )
selecteren nieuw { WerknemersnaamNaam = werknemersnaam.Naam, Afdelingsnaam = afdeling?.Naam ?? 'Geen' } ;
voor elk ( was het resultaat in vraag )
{
Console.WriteLine ( $ 'Naam medewerker: {result.Naam medewerker}, afdeling: {result.Naam afdeling}' ) ;
}
}
}
klasse Medewerkernaam
{
openbare int-id { krijgen; set ; }
openbare tekenreeksnaam { krijgen; set ; }
public int DepartmentId { krijgen; set ; }
}
klasse Afdeling
{
openbare int-id { krijgen; set ; }
openbare tekenreeksnaam { krijgen; set ; }
}
}
Eerst worden voorbeeldgegevens gegeven die de naam van de werknemer en de naam van afdelingen bevatten en daarna wordt aan elk een respectief nummer gegeven. Vervolgens wordt de join-bewerking uitgevoerd met behulp van de opdracht join en daarna wordt het resultaat opgeslagen in een variabele met de naam query, vervolgens wordt de for-lus gebruikt om de namen en afdelingen van de respectievelijke werknemers af te drukken en de uitvoer van de code zal er als volgt uitzien :
Conclusie
Left outer join is een gebruikelijke bewerking in SQL en kan ook eenvoudig worden uitgevoerd met LINQ in C#. Met de methoden GroupJoin() en SelectMany() kunt u left outer joins uitvoeren op twee reeksen op basis van een gemeenschappelijke sleutel. Hoewel de syntaxis voor het uitvoeren van left outer joins in LINQ misschien moeilijk te begrijpen is voor beginners, is het een krachtige en flexibele taal waarmee complexe query's eenvoudig kunnen worden uitgevoerd.