Comment effectuer la jointure externe gauche en C # LINQ aux objets sans utiliser de join-on-equals-into
clauses? Y a-t-il moyen de le faire avec l' where
article? Problème correct: pour la jointure interne est facile et j'ai une solution comme celle-ci
List<JoinPair> innerFinal = (from l in lefts from r in rights where l.Key == r.Key
select new JoinPair { LeftId = l.Id, RightId = r.Id})
mais pour la jointure externe gauche, j'ai besoin d'une solution. Le mien est quelque chose comme ça mais ça ne marche pas
List< JoinPair> leftFinal = (from l in lefts from r in rights
select new JoinPair {
LeftId = l.Id,
RightId = ((l.Key==r.Key) ? r.Id : 0
})
où JoinPair est une classe:
public class JoinPair { long leftId; long rightId; }
Réponses:
Comme indiqué sur:
101 échantillons LINQ - jointure externe gauche
la source
Si un fournisseur LINQ piloté par une base de données est utilisé, une jointure externe gauche beaucoup plus lisible peut être écrite comme telle:
Si vous omettez le,
DefaultIfEmpty()
vous aurez une jointure interne.Prenez la réponse acceptée:
Cette syntaxe est très déroutante, et il n'est pas clair comment cela fonctionne lorsque vous souhaitez quitter les tables MULTIPLE.
Remarque
Il convient de noter que
from alias in Repo.whatever.Where(condition).DefaultIfEmpty()
c'est la même chose qu'une application externe / jointure latérale gauche, que tout optimiseur de base de données (décent) est parfaitement capable de traduire en jointure gauche, tant que vous n'introduisez pas de ligne par ligne. -valeurs (alias une application externe réelle). Ne faites pas cela dans Linq-2-Objects (car il n'y a pas d'optimiseur de base de données lorsque vous utilisez Linq-to-Objects).Exemple détaillé
Lorsqu'il est utilisé avec LINQ 2 SQL, il se traduira parfaitement par la requête SQL très lisible suivante:
Éditer:
Voir aussi " Convertir une requête SQL Server en requête Linq » pour un exemple plus complexe.
De plus, si vous le faites dans Linq-2-Objects (au lieu de Linq-2-SQL), vous devez le faire à l'ancienne (car LINQ to SQL le traduit correctement pour joindre des opérations, mais sur des objets, cette méthode force une analyse complète, et ne tire pas parti des recherches d'index, peu importe ...):
la source
join
est beaucoup plus lisible et claire que cellewhere
suivie parDefaultIfEmpty
Utilisation de l'expression lambda
la source
Enumerable.Empty<Product>.DefaultIfEmpty()
qui signifie retournera un IEnumerable avec une seule valeur dedefault(Product)
.Maintenant comme méthode d'extension:
Utilisez comme vous utiliseriez normalement join:
J'espère que cela vous fera gagner du temps.
la source
Jetez un oeil à cet exemple . Cette requête devrait fonctionner:
la source
r
on accéder à la clause select après avoir utilisé une jointure dans?r
dans la deuxièmefrom
clause. à savoirfrom r in lrs.DefaultIfEmpty()
Sinon , cette requête n'a pas beaucoup de sens et n'a probablement même pas compiler en raison d'r
être hors contexte pour la sélection.Clockwise
avec John Cleese, lol.Une implémentation de la jointure externe gauche par des méthodes d'extension pourrait ressembler à
Le sélecteur de résultats doit alors prendre en charge les éléments nuls. Fx.
la source
regardez cet exemple
maintenant vous pouvez
include elements from the left
même si cet élémenthas no matches in the right
, dans notre cas, nous sommes revenusArlene
même s'il n'a pas de correspondance dans la droitevoici la référence
Comment: effectuer des jointures externes gauches (Guide de programmation C #)
la source
Ceci est le formulaire général (comme déjà fourni dans d'autres réponses)
Cependant, voici une explication qui, je l'espère, clarifiera ce que cela signifie réellement!
crée essentiellement un jeu de résultats séparé b_temp qui inclut effectivement des «lignes» nulles pour les entrées sur le côté droit (entrées dans «b»).
Puis la ligne suivante:
..itère sur cet ensemble de résultats, en définissant la valeur nulle par défaut pour la 'ligne' sur le côté droit et en définissant le résultat de la jointure de la ligne de droite sur la valeur de 'b_value' (c'est-à-dire la valeur qui est à droite côté côté, s'il y a un enregistrement correspondant, ou «null» s'il n'y en a pas).
Maintenant, si le côté droit est le résultat d'une requête LINQ distincte, il sera composé de types anonymes, qui ne peuvent être que «quelque chose» ou «nul». Si c'est un énumérable cependant (par exemple une liste - où MyObjectB est une classe avec 2 champs), alors il est possible d'être précis sur les valeurs par défaut 'null' qui sont utilisées pour ses propriétés:
Cela garantit que 'b' lui-même n'est pas nul (mais ses propriétés peuvent être nulles, en utilisant les valeurs nulles par défaut que vous avez spécifiées), et cela vous permet de vérifier les propriétés de b_value sans obtenir une exception de référence nulle pour b_value. Notez que pour un DateTime nullable, un type de (DateTime?) C'est-à-dire 'DateTime nullable' doit être spécifié comme 'Type' du null dans la spécification pour 'DefaultIfEmpty' (cela s'appliquera également aux types qui ne sont pas 'nativement' 'nullable par exemple double, float).
Vous pouvez effectuer plusieurs jointures externes gauches en enchaînant simplement la syntaxe ci-dessus.
la source
Voici un exemple si vous devez joindre plus de 2 tables:
Réf: https://stackoverflow.com/a/17142392/2343
la source
Méthode d'extension qui fonctionne comme la jointure gauche avec la syntaxe Join
vient de l'écrire dans .NET core et il semble fonctionner comme prévu.
Petit test:
la source
Voici une version assez facile à comprendre en utilisant la syntaxe de la méthode:
la source
Il existe trois tableaux: personnes, écoles et personnes_écoles, qui connectent les personnes aux écoles dans lesquelles ils étudient. Une référence à la personne avec id = 6 est absente dans le tableau personnes_écoles. Cependant, la personne avec id = 6 est présentée dans la grille résultat jointe à gauche.
la source
Il s'agit d'une syntaxe SQL comparable à la syntaxe LINQ pour les jointures internes et externes externes. Jointure externe gauche:
http://www.ozkary.com/2011/07/linq-to-entity-inner-and-left-joins.html
"L'exemple suivant fait une jointure de groupe entre le produit et la catégorie. Il s'agit essentiellement de la jointure gauche. L'expression into renvoie des données même si la table des catégories est vide. Pour accéder aux propriétés de la table des catégories, nous devons maintenant sélectionner le résultat énumérable en ajoutant le from cl dans l'instruction catList.DefaultIfEmpty ().
la source
Effectuer des jointures externes gauches dans linq C # // Effectuer des jointures externes gauches
https://dotnetwithhamid.blogspot.in/
la source
Je voudrais ajouter que si vous obtenez l'extension MoreLinq, il y a maintenant un support pour les jointures gauches homogènes et hétérogènes maintenant
http://morelinq.github.io/2.8/ref/api/html/Overload_MoreLinq_MoreEnumerable_LeftJoin.htm
exemple:
ÉDITER:
Rétrospectivement, cela peut fonctionner, mais il convertit l'IQueryable en un IEnumerable car morelinq ne convertit pas la requête en SQL.
Vous pouvez à la place utiliser un GroupJoin comme décrit ici: https://stackoverflow.com/a/24273804/4251433
Cela garantira qu'il restera comme un IQueryable au cas où vous auriez besoin de faire d'autres opérations logiques dessus plus tard.
la source
Le moyen le plus simple consiste à utiliser le mot clé Let. Cela fonctionne pour moi.
Il s'agit d'une simulation de Left Join. Si chaque élément de la table B ne correspond pas à un élément A, BItem renvoie null
la source
Si vous devez joindre et filtrer quelque chose, cela peut être fait en dehors de la jointure. Le filtrage peut être effectué après la création de la collection.
Dans ce cas, si je le fais dans la condition de jointure, je réduis les lignes qui sont retournées.
La condition ternaire est utilisée
(= n == null ? "__" : n.MonDayNote,)
Si l'objet est
null
(donc pas de correspondance), retournez ce qui se trouve après le?
.__
, dans ce cas.Sinon, ce retour est après
:
,n.MonDayNote
.Merci aux autres contributeurs, c'est là que j'ai commencé avec mon propre problème.
la source
PRODUCTION
la source
Selon ma réponse à une question similaire, ici:
Liaison externe gauche Linq vers SQL à l'aide de la syntaxe Lambda et jointure sur 2 colonnes (clé de jointure composite)
Obtenez le code ici , ou clonez mon dépôt github , et jouez!
Requete:
Lambda:
la source
Vue d'ensemble: dans cet extrait de code, je montre comment regrouper par ID où Table1 et Table2 ont une relation un à plusieurs. Je groupe sur Id, Field1 et Field2. La sous-requête est utile, si une troisième recherche de table est requise et qu'elle aurait nécessité une relation de jointure gauche. Je montre un groupement de jointure gauche et une sous-requête linq. Les résultats sont équivalents.
la source
la source
Solution simple pour LEFT OUTER JOIN :
notes :
la source
setA
etsetB
la réponse.