Pour afficher les enregistrements correspondants de la table de gauche et de la table de droite dans SQL, la jointure externe gauche est un type d'opération de jointure utilisée. Dans LINQ, la jointure externe gauche peut être effectuée à l'aide des méthodes GroupJoin() et SelectMany(). Cet article traitera en détail de l'exécution de jointures externes gauches dans LINQ à l'aide de C#.
Comment effectuer des jointures externes gauches dans LINQ à l'aide de C#
Pour effectuer une jointure externe gauche dans LINQ, vous pouvez utiliser la méthode GroupJoin() pour joindre deux séquences basées sur une clé commune, puis utiliser la méthode SelectMany() pour aplatir le résultat, voici un exemple :
utiliser le système ;
en utilisant System.Linq ;
Programme de classe
{
vide statique principal ( )
{
var gauche = nouveau [ ] { 1 , 2 , 3 } ;
var droite = nouveau [ ] { 2 , 3 , 4 } ;
var result = left.GroupJoin (
droite,
l = > je,
r = > r,
( g / D ) = > nouveau { Gauche = l, Droite = r.DefaultIfEmpty ( ) } )
.SelectMany (
lr = > lr.Right.Select (
r = > nouveau { Gauche = lr.Gauche, Droite = r } ) ) ;
pour chaque ( article variable dans résultat )
{
Console.WriteLineConsole.WriteLine ( '{0} {1}' , élément.Gauche, élément.Droite ) ;
}
}
}
Ce code effectue une jointure externe gauche sur deux tableaux gauche et droit et imprime le résultat sur la console. La méthode GroupJoin() effectue la jointure, et la SelectMany() 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 illustre l'utilisation de l'exécution de jointures laissées en affichant les noms des employés respectifs et leurs départements concernés. Chaque employé de chaque département a reçu un numéro qui est ensuite utilisé pour faire correspondre le département concerné à l'employé respectif, voici le code complet pour celui-ci :
utiliser le système ;en utilisant System.Collections.Generic ;
en utilisant System.Linq ;
espace de noms Votreespace de noms
{
Programme de classe
{
vide statique principal ( chaîne [ ] arguments )
{
Liste < Nom de l'employé > employés = nouvelle liste < Nom de l'employé >
{
nouveau nom d'employé { identifiant = 1 , Nom = 'Lui-même' , ID de service = 1 } ,
nouveau nom d'employé { identifiant = 2 , Nom = 'John' , ID de service = 2 } ,
nouveau nom d'employé { identifiant = 3 , Nom = 'Kévin' , ID de service = 2 } ,
nouveau nom d'employé { identifiant = 4 , Nom = 'Bob' , ID de service = 3 }
} ;
Liste < Département > départements = nouvelle liste < Département >
{
nouveau département { identifiant = 1 , Nom = 'Rédaction de contenu' } ,
nouveau département { identifiant = 2 , Nom = 'Commercialisation' } ,
nouveau département { identifiant = 3 , Nom = 'Ingénierie' }
} ;
var requête = du nom de l'employé dans employés
rejoindre département dans départements
sur employeename.DepartmentId est égal à department.Id dans departmentGroup
du département dans departmentGroup.DefaultIfEmpty ( )
sélectionner nouveau { EmployeenameName = employeename.Name, DepartmentName = department?.Name ?? 'Aucun' } ;
pour chaque ( était le résultat dans mettre en doute )
{
Console.WriteLineConsole.WriteLine ( $ 'Nom de l'employé : {result.Employeename}, Service : {result.DepartmentName}' ) ;
}
}
}
classe Nom de l'employé
{
identifiant public int { obtenir; ensemble ; }
nom de chaîne publique { obtenir; ensemble ; }
public int DepartmentId { obtenir; ensemble ; }
}
département de classe
{
identifiant public int { obtenir; ensemble ; }
nom de chaîne publique { obtenir; ensemble ; }
}
}
Tout d'abord, un exemple de données contenant le nom de l'employé et le nom des départements est fourni, puis un numéro respectif est attribué à chacun. Ensuite, l'opération de jointure est effectuée à l'aide de 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 les départements des employés respectifs et la sortie du code sera comme ceci :
Conclusion
La jointure externe gauche est une opération courante dans SQL et peut également être effectuée facilement à l'aide de LINQ en C#. À l'aide des méthodes GroupJoin() et SelectMany(), vous pouvez effectuer des jointures externes gauches sur deux séquences basées sur une clé commune. Bien que la syntaxe pour effectuer des jointures externes gauches dans LINQ puisse être difficile à comprendre pour les débutants, il s'agit d'un langage puissant et flexible qui permet d'effectuer facilement des requêtes complexes.