Comment effectuer les jointures externes gauche - Linq en C #

Pour afficher les enregistrements correspondants de la table gauche et de la table droite en SQL, la jointure extérieure gauche est un type d'opération de jointure qui est utilisée. Dans Linq, la jointure extérieure gauche peut être effectuée à l'aide des méthodes GroupJoin () et SelectMany (), cet article discutera largement de la réalisation de jointures extérieures gauche dans Linq en utilisant C #.

Comment effectuer des jointures externes gauche dans Linq en utilisant C #

Pour effectuer une jointure extérieure gauche dans LINQ, vous pouvez utiliser la méthode GroupJoin () pour rejoindre deux séquences basées sur une clé commune, puis utiliser la méthode SelectMany () pour aplatir le résultat, voici un exemple:

Utilisation du système;
Utilisation du système.Linq;
programme de classe

vide statique Main ()

var Left = new [] 1, 2, 3;
var droit = ​​new [] 2, 3, 4;
Résultat var = gauche.GroupJoin (
droite,
l => l,
r => r,
(l, r) => new gauche = l, droit = ​​r.DefaultIfEmpty ())
.SelectMany (
LR => LR.Droite.Sélectionner(
r => new Left = lr.Gauche, droit = ​​r));
foreach (élément var dans le résultat)

Console.WriteLine ("0 1", élément.Gauche, article.Droite);

Ce code effectue une jointure extérieure gauche sur deux tableaux à gauche et à droite, et imprime le résultat à la console. La méthode GroupJoin () effectue la jointure et le SelectMany () la méthode est utilisée pour aplatir le résultat. Enfin, le résultat est imprimé sur la console à l'aide d'une boucle foreach et de la fonction writeLine ():

Voici un autre exemple qui démontre l'utilisation de la réalisation des jointures laissées en affichant des noms d'employés respectifs et de leurs départements pertinents. Chaque employé est que chaque département a reçu un nombre qui sont ensuite utilisés pour faire correspondre le département concerné à l'employé respectif, voici le code complet pour cela:

Utilisation du système;
Utilisation du système.Collections.Générique;
Utilisation du système.Linq;
Espace de noms votre espace de noms

programme de classe

statique void main (String [] args)

Liste employés = nouvelle liste

Nouveau employeename id = 1, name = "sam", départementid = 1,
Nouveau employeename id = 2, name = "jhon", départementid = 2,
Nouveau employeename id = 3, name = "kevin", départementid = 2,
Nouveau employeename id = 4, name = "bob", départementid = 3
;
Liste départements = nouvelle liste

Nouveau département id = 1, name = "Content Writing",
nouveau département id = 2, name = "marketing",
nouveau département id = 3, name = "ingénierie"
;
var query = de l'employeen dans les employés
Rejoignez le département dans les départements
sur Employeename.Département égal à département.ID dans le groupe de département
du département du département.DefaultIfEmpty ()
Sélectionnez New EmployEenameName = Employeename.Nom, DepartmentName = Department?.Nom ?? "Aucun" ;
foreach (var entraîne la requête)

Console.WriteLine ($ "Employeename: Résultat.Employeenamename, département: Résultat.Nom du département");



EmployeaName de classe

public int id get; ensemble;
Nom de chaîne publique get; ensemble;
public int départementid get; ensemble;

département de classe

public int id get; ensemble;
Nom de chaîne publique get; ensemble;

D'abord un exemple de données est donnée qui contient le nom des employés et le nom des départements et ensuite un numéro respectif est donné à chaque. Ensuite, l'opération de jointure est effectuée en utilisant la commande join et après cela, le résultat est enregistré dans une variable nommée Query, ensuite la boucle For est utilisée pour imprimer les noms et départements des employés respectifs et la sortie du code sera comme ceci :

Conclusion

La jointure extérieure gauche est une opération courante dans SQL et peut également être effectuée facilement en utilisant LINQ en C #. En utilisant les méthodes GroupJoin () et SelectMany (), vous pouvez effectuer des jointures externes gauche sur deux séquences basées sur une clé commune. Bien que la syntaxe pour effectuer des jointures externes gauche à Linq puisse être difficile à comprendre pour les débutants, c'est un langage puissant et flexible qui permet de réaliser des requêtes complexes.