Come eseguire join esterni sinistra - LINQ in c#

Per visualizzare i record corrispondenti dalla tabella sinistra e dalla tabella destra in SQL, il join esterno sinistro è un tipo di operazione di join utilizzata. In Linq, il join esterno sinistro può essere eseguito utilizzando i metodi GroupJoin () e SelectMany (), questo articolo discuterà ampiamente eseguendo i join esterni sinistra in LINQ usando C#.

Come eseguire i join esterni sinistra in LINQ usando C#

Per eseguire un join esterno sinistro in LINQ, è possibile utilizzare il metodo GroupJoin () per unire due sequenze in base a una chiave comune e quindi utilizzare il metodo SelectMany () per appiattire il risultato, ecco un esempio:

usando il sistema;
Utilizzo del sistema.Linq;
Programma di classe

void statico main ()

var left = new [] 1, 2, 3;
var destro = new [] 2, 3, 4;
var result = a sinistra.GroupJoin (
Giusto,
l => l,
r => r,
(l, r) => new left = l, destra = r.DefaultiFempty ())
.SelectMany (
lr => lr.Giusto.Selezionare(
r => new left = lr.Sinistra, a destra = r));
foreach (elemento var in risultato)

Console.WriteLine ("0 1", elemento.A sinistra, articolo.Giusto);

Questo codice esegue un join esterno sinistro su due array sinistra e destra e stampa il risultato sulla console. Il metodo GroupJoin () esegue il join e il SelectMany () il metodo viene utilizzato per appiattire il risultato. Infine, il risultato viene stampato sulla console usando una funzione foreach loop e writeline ():

Ecco un altro esempio che dimostra l'uso dell'esecuzione dei giunti lasciati mostrando i rispettivi nomi dei dipendenti e i loro dipartimenti pertinenti. A ciascun dipendente è stato assegnato a ciascun dipendente che viene assegnato un numero che viene quindi utilizzato per abbinare il dipartimento pertinente al rispettivo dipendente, ecco il codice completo per esso:

usando il sistema;
Utilizzo del sistema.Collezioni.Generico;
Utilizzo del sistema.Linq;
spazio dei nomi youramespace

Programma di classe

statico void main (string [] args)

Elenco dipendenti = nuovo elenco

NUOVO ESPETTANOENAME id = 1, name = "sam", dipartimentId = 1,
New EmployeEename id = 2, name = "jhon", dipartimentId = 2,
New EmployeEename id = 3, name = "Kevin", dipartimentId = 2,
New EmployeEename id = 4, name = "bob", dipartimentId = 3
;
Elenco Dipartimenti = nuovo elenco

Nuovo dipartimento id = 1, name = "Writing content",
Nuovo dipartimento id = 2, name = "marketing",
Nuovo dipartimento id = 3, nome = "ingegneria"
;
var query = da Employeename nei dipendenti
Unisciti al dipartimento nei dipartimenti
su Employeename.DipartimentoID è uguale al dipartimento.ID nel gruppo di dipartimento
Dal dipartimento del dipartimento.DefaultiFempty ()
Seleziona nuovo EmployeenAMename = EmployeEename.Nome, Dipartimento di Dipartimento = Dipartimento?.Nome ?? "Nessuno" ;
foreach (var risulta in query)

Console.WriteLine ($ "Employeename: risultato.EmployeenAMename, dipartimento: risultato.Nome Dipartimento");



Classe Employeename

public int id get; impostato;
Nome della stringa pubblica get; impostato;
Public int DipartimentoId get; impostato;

Dipartimento di classe

public int id get; impostato;
Nome della stringa pubblica get; impostato;

Per prima cosa vengono forniti dati di esempio che contiene il nome del dipendente e il nome dei dipartimenti e successivamente viene dato un numero rispettivo a ciascuno. Successivamente l'operazione di join viene eseguita utilizzando il comando di join e successivamente il risultato viene salvato in una variabile denominata query, successivamente il loop viene utilizzato per stampare i nomi e i dipartimenti dei rispettivi dipendenti e l'output del codice sarà così :

Conclusione

Il join esterno sinistro è un'operazione comune in SQL e può anche essere eseguita facilmente usando LINQ in C#. Utilizzando i metodi GroupJoin () e SelectMany (), è possibile eseguire i giunti esterni a sinistra su due sequenze basate su una chiave comune. Sebbene la sintassi per eseguire i giunti esterni sinistra in LINQ possa essere difficile da capire per i principianti, è un linguaggio potente e flessibile che consente di eseguire facilmente query complesse.