Per visualizzare i record corrispondenti dalla tabella di sinistra e dalla tabella di destra in SQL, il join esterno sinistro è un tipo di operazione di join utilizzata. In LINQ, il left outer join può essere eseguito usando i metodi GroupJoin() e SelectMany(), questo articolo discuterà ampiamente dell'esecuzione di left outer join in LINQ usando C#.
Come eseguire join esterni sinistri in LINQ utilizzando C#
Per eseguire un left outer join in LINQ, puoi utilizzare il metodo GroupJoin() per unire due sequenze basate su una chiave comune e quindi utilizzare il metodo SelectMany() per appiattire il risultato, ecco un esempio:
utilizzando il sistema;
utilizzando System.Linq;
programma di classe
{
vuoto statico principale ( )
{
var sinistra = nuovo [ ] { 1 , 2 , 3 } ;
var destra = nuovo [ ] { 2 , 3 , 4 } ;
var result = left.GroupJoin (
Giusto,
l = > io,
r = > R,
( l, d ) = > nuovo { Sinistra = l, Destra = r.DefaultIfEmpty ( ) } )
.SelezionaMolti (
lr = > lr.Right.Select (
r = > nuovo { Sinistra = lr.Sinistra, Destra = r } ) ) ;
per ciascuno ( elemento var In risultato )
{
Console.WriteLine ( '{0} {1}' , oggetto.Sinistra, oggetto.Destra ) ;
}
}
}
Questo codice esegue un left outer join su due array sinistro e destro e stampa il risultato nella console. Il metodo GroupJoin() esegue il join e il SelezionaMolti() metodo viene utilizzato per appiattire il risultato. Infine, il risultato viene stampato sulla console utilizzando un ciclo foreach e la funzione WriteLine():
Ecco un altro esempio che dimostra l'utilizzo dell'esecuzione di join esclusi visualizzando i rispettivi nomi dei dipendenti e i relativi reparti. A ciascun dipendente e a ciascun dipartimento è stato assegnato un numero che viene quindi utilizzato per abbinare il dipartimento pertinente al rispettivo dipendente, ecco il codice completo per esso:
utilizzando il sistema;utilizzando System.Collections.Generic;
utilizzando System.Linq;
spazio dei nomi Il tuo spazio dei nomi
{
programma di classe
{
vuoto statico principale ( corda [ ] arg )
{
Elenco < Nome dipendente > dipendenti = nuovo Elenco < Nome dipendente >
{
nuovo nomeimpiegato { id = 1 , Nome = 'Lui stesso' , IDDipartimento = 1 } ,
nuovo nomeimpiegato { id = 2 , Nome = 'John' , IDDipartimento = 2 } ,
nuovo nomeimpiegato { id = 3 , Nome = 'Kevin' , IDDipartimento = 2 } ,
nuovo nomeimpiegato { id = 4 , Nome = 'Bob' , IDDipartimento = 3 }
} ;
Elenco < Dipartimento > reparti = nuovo Elenco < Dipartimento >
{
nuovo Dipartimento { id = 1 , Nome = 'Scrittura di contenuti' } ,
nuovo Dipartimento { id = 2 , Nome = 'Marketing' } ,
nuovo Dipartimento { id = 3 , Nome = 'Ingegneria' }
} ;
var query = da nomeimpiegato In dipendenti
giuntura Dipartimento In dipartimenti
on employeename.DepartmentId è uguale a department.Id in departmentGroup
dal dipartimento In departmentGroup.DefaultIfEmpty ( )
Selezionare nuovo { NomeimpiegatoNome = nomeimpiegato.Nome, NomeDipartimento = reparto?.Nome ?? 'Nessuno' } ;
per ciascuno ( era il risultato In domanda )
{
Console.WriteLine ( $ 'Nome impiegato: {result.EmployeenameName}, reparto: {result.DepartmentName}' ) ;
}
}
}
classe nomeimpiegato
{
ID pubblico int { Ottenere; impostato ; }
stringa pubblica Nome { Ottenere; impostato ; }
public int DepartmentId { Ottenere; impostato ; }
}
Dipartimento di classe
{
ID pubblico int { Ottenere; impostato ; }
stringa pubblica Nome { Ottenere; impostato ; }
}
}
Per prima cosa viene fornito un dato di esempio che contiene il nome del dipendente e il nome dei reparti e successivamente viene assegnato un numero rispettivo a ciascuno. Successivamente viene eseguita l'operazione di join utilizzando il comando join e successivamente il risultato viene salvato in una variabile denominata query, quindi viene utilizzato il ciclo for per stampare i nomi e i reparti dei rispettivi dipendenti e l'output del codice sarà così :
Conclusione
Left outer join è un'operazione comune in SQL e può anche essere eseguita facilmente utilizzando LINQ in C#. Utilizzando i metodi GroupJoin() e SelectMany(), è possibile eseguire join esterni sinistri su due sequenze basate su una chiave comune. Sebbene la sintassi per l'esecuzione di left outer join in LINQ possa essere difficile da comprendere per i principianti, è un linguaggio potente e flessibile che consente di eseguire facilmente query complesse.