JOINTURE EXTERNE GAUCHE dans LINQ to objects

Votre propre réponse est bien, mais ce n'est pas très élégant. Donc, oui, c'est un peu sale. Il y a un niveau moyen de faire une jointure externe gauche, qui s'occupe de votre exemple et serait en mesure de gérer les cas où il y a les villes en double. Votre exemple ne peut pas gérer les villes en double parce que tous les doublons sont ignorés lorsque vous sélectionnez c2s.First().

La norme de gauche joindre les étapes sont les suivantes:

1. Créer une hiérarchie de vos données à l'aide de GroupJoin.
2. Aplatir la hiérarchie avec SelectMany.

Votre GroupJoin est l'aplatissement de la hiérarchie en une seule étape, en ignorant tout, sauf le premier correspondant à la ville. C'est ce qui est sale à ce sujet. Si vous essayez d'utiliser ce code dans le sens inverse en prenant les villes de gauche et de se joindre à eux sur les lieux, vous n'aurez qu'une seule place par la ville de! C'est évidemment mauvais. Il est préférable d'apprendre à faire une jointure gauche la bonne façon, et puis il le sera toujours.

La SelectMany à l'étape 2 est réellement en option si vous souhaitez conserver la hiérarchie et puis imbriquer les boucles foreach pour les afficher, mais je vais supposer que vous souhaitez afficher les données dans une table à plat format.

Si vous voulez juste pour voir la réponse à votre problème concret, faites défiler jusqu'à "des Villes et des Lieux" de la rubrique ci-dessous, mais d'abord, voici un exemple complet à l'aide de deux simples tableaux de chaîne.

Abstraite Exemple avec Explication Complète

Voici un exemple complet à l'aide de deux tableaux de lettres à la place de votre code. Je voulais montrer un exemple simple d'abord. Vous pouvez les copier et les coller dans LINQPad et à définir la Langue "C# Consolidés", et l'exécuter pour vous-même si vous le souhaitez. Je très recommander LINQPad comme un outil pour tester toutes sortes de code, pas seulement LINQ. Alternativement, vous pouvez également créer une application console dans Visual Studio.

Voici le code sans trop de commentaires. Ci-dessous c'est une version qui est abondamment commentés. Vous pouvez sauter à la, si vous voulez savoir exactement ce que chaque paramètre moyens.

var leftLetters = new string[]{ "A", "B", "C" };
var rightLetters = new string[]{ "A", "B" };

//Create a hierarchical collection that includes every left item paired with a collection of matching right items (which may be empty if there are no matching right items.)
var groupJoin =
    leftLetters.GroupJoin(
        rightLetters, 
        leftLetter => leftLetter, 
        rightLetter => rightLetter, 
        ( leftLetter, matchingRightLetters ) => new { leftLetter, matchingRightLetters } 
    );

//Flatten the groupJoin hierarchical collection with a SelectMany
var selectMany = 
    groupJoin.SelectMany(           
        groupJoinItem => groupJoinItem.matchingRightLetters.DefaultIfEmpty( "MISSING" ),            
        ( groupJoinItem, rightLetter ) => new {
            LeftLetter = groupJoinItem.leftLetter, 
            RightLetter = rightLetter 
        }
    );

//You can think of the elements of selectMany as "rows" as if this had been a left outer join in SQL. But this analogy breaks down rapidly if you are selecting objects instead of scalar values.
foreach( var row in selectMany )
{
    Console.WriteLine( row.LeftLetter + ", " + row.RightLetter );
}

Voici le résultat, qui doit être assez évident, car nous savons tous ce qu'est une jointure gauche est censé faire.

A, A
B, B
C, MISSING

Lourdement version annotée:

var leftLetters = new string[]{ "A", "B", "C" };
var rightLetters = new string[]{ "A", "B" };

//Create a hierarchical collection that includes every left item paired with a collection of matching right items (which may be empty if there are no matching right items.)
var groupJoin =
    leftLetters.GroupJoin(
        rightLetters, //inner: the right hand collection in the join
        leftLetter => leftLetter, //outerKeySelector: There is no property to use as they join key, the letter *is* the key. So this lambda simply returns the parameter itself.
        rightLetter => rightLetter, //innerKeySelector: Same with the rightLetters
        ( leftLetter, matchingRightLetters ) => new { leftLetter, matchingRightLetters } //resultSelector: given an element from the left items, and its matching collection of right items, project them to some class. In this case we are using a new anonymous type. 
    );

//Flatten the groupJoin hierarchical collection with a SelectMany
var selectMany = 
    groupJoin.SelectMany(
        //collectionSelector: given a single element from our collection of group join items from above, provide a collection of its "right" items which we want to flatten out. In this case the right items are in a property of the groupJoinItem itself, but this does not need to be the case! We use DefaultIfEmpty to turn an empty collection into a new collection that has exactly one item instead: the string "MISSING".
        groupJoinItem => groupJoinItem.matchingRightLetters.DefaultIfEmpty( "MISSING" ), 
        //resultSelector: SelectMany does the flattening for us and this lambda gets invoked once for *each right item* in a given left item's collection of right items.
        ( 
            groupJoinItem, //The first parameter is one of the original group join item, including its entire collection of right items, but we will ignore that collection in the body of this lamda and just grab the leftLetter property.
            rightLetter //The second parameter is *one* of the matching right items from the collection of right items we selected in the first lambda we passed into SelectMany.
        )  
            => new {
                LeftLetter = groupJoinItem.leftLetter, //groupJoinItem is one of the original items from the GroupJoin above. We just want the left letter from it.
                RightLetter = rightLetter //This is one of the individual right letters, so just select it as-is.
            }
    );

//You can think of the elements of selectMany as "rows" as if this had been a left outer join in SQL. But this analogy breaks down rapidly if you are selecting objects instead of scalar values.
foreach( var row in selectMany )
{
    Console.WriteLine( row.LeftLetter + ", " + row.RightLetter );
}   

De nouveau, la sortie de la référence:

A, A
B, B
C, MISSING

Au-dessus de l'utilisation de LINQ est souvent appelé la "méthode de la chaîne". Vous prenez des collections et de la chaîne d'ensemble des méthodes pour obtenir ce que vous voulez. (La plupart du temps vous n'avez pas utiliser des variables pour stocker les expressions individuelles. Vous venez de faire GroupJoin(...).SelectMany(...), c'est pourquoi elle est appelée "méthode de la chaîne". Il est très détaillé et explicite, et prend beaucoup de temps pour écrire.

Au lieu de cela, nous pouvons utiliser ce qu'on appelle une "compréhension", de la requête "compréhension" ou "LINQ compréhension". La compréhension est un ancien ordinateur de la science terme à partir des années 1970, qui honnêtement n'a pas beaucoup de sens pour la plupart des gens. Au lieu de cela les gens les appellent "les requêtes LINQ", ou "expressions LINQ", mais ceux théoriquement s'appliquer à la méthode des chaînes de bien, parce que dans les deux cas, vous êtes la construction d'une arborescence d'expression. (Expression arbres sont en dehors de la portée de ce tutoriel.) Une LINQ la compréhension est une syntaxe de type SQL pour l'écriture de LINQ, mais ce n'est pas SQL! Il n'a rien à voir avec SQL réel. Voici le même code écrit comme une requête de compréhension:

var leftLetters = new string[]{ "A", "B", "C" };
var rightLetters = new string[]{ "A", "B" };

var query = 
    from leftLetter in leftLetters
    join rightLetter in rightLetters
    on leftLetter equals rightLetter into matchingRightLetters
    from rightLetter in matchingRightLetters.DefaultIfEmpty( "MISSING" )
    select new
    {
        LeftLetter = leftLetter,
        RightLetter = rightLetter
    };

foreach( var row in query )
{
    Console.WriteLine( row.LeftLetter + ", " + row.RightLetter );
}   

Cela permettra de compiler pour le exacte même code comme dans l'exemple ci-dessus, sauf que le paramètre nommé "groupJoinItem" dans le SelectMany sera nommé quelque chose comme "temp0", car ce paramètre n'est pas explicitement existe pas dans la compréhension de la version de ce code.

Je pense que vous pouvez comprendre comment beaucoup plus simple de cette version du code. J'ai toujours utiliser cette syntaxe lors d'une jointure externe gauche. Je n'ai jamais utiliser GroupJoin avec SelectMany. Cependant, à première vue, il fait très peu de sens. Un join suivie par un into crée un GroupJoin. Vous devez d'abord savoir ce, et pourquoi vous voulez cette. Ensuite, la deuxième from indique une SelectMany, ce qui n'est pas évidente. Lorsque vous avez deux from mots-clés vous sont effectivement la création d'une jointure croisée (produit cartésien), qui est ce SelectMany est en train de faire. (En quelque sorte.)

Par exemple, cette requête:

from leftLetter in leftLetters
from rightLetter in rightLetters
select new
{
    LeftLetter = leftLetter,
    RightLetter = rightLetter
}

donnerait:

A, A
A, B
B, A
B, B
C, A
C, B

C'est une base de jointure croisée.

Donc, revenons à notre gauche d'origine joindre requête LINQ: La première from de la requête est le groupe de la rejoindre, et la deuxième from exprime une jointure croisée entre chaque groupJoinItem et sa propre collection de la correspondance de droit lettres. C'est un peu comme ceci:

from groupJoinItem in groupJoin
from rightLetter in groupJoinItem.matchingRightLetters
select new{...}

En fait, nous avons effectivement pu l'écrire en tant que tel!

var groupJoin = 
    from leftLetter in leftLetters
    join rightLetter in rightLetters
    on leftLetter equals rightLetter into matchingRightLetters
    select new 
    {
        LeftLetter = leftLetter,
        MatchingRightLetters = matchingRightLetters
    };


var selectMany = 
    from groupJoinItem in groupJoin 
    from rightLetter in groupJoinItem.MatchingRightLetters.DefaultIfEmpty( "MISSING" )
    select new
    {
        LeftLetter = groupJoinItem.LeftLetter,
        RightLetter = rightLetter
    };

Que selectMany exprime la suivante: "pour chaque élément dans groupJoin, croix joindre à son propre MatchingRightLetters des biens, et de les enchaîner tous les résultats ensemble." Cela donne exactement le même résultat que l'un de nos gauche joindre le code ci-dessus.

C'est sans doute trop beaucoup d'une explication à cette simple question, mais je n'aime pas de culte du cargo de programmation (google). Vous devez savoir exactement ce que votre code est en train de faire, et pourquoi, sinon vous ne serez pas en mesure de s'attaquer à des problèmes plus complexes.

Des villes et des Lieux

Alors, voici la méthode de la chaîne de version de votre code. C'est tout un programme afin que les gens puissent l'exécuter si ils le souhaitent (Utiliser le "Programme C#" type de langue de LINQPad ou de faire une console application avec Visual Studio ou le Compilateur C#.)

void Main()
{
City[] cities = new City[]{
new City{CityCode="0771",CityName="Raipur",CityPopulation="BIG"},
new City{CityCode="0751",CityName="Gwalior",CityPopulation="MEDIUM"},
new City{CityCode="0755",CityName="Bhopal",CityPopulation="BIG"},
new City{CityCode="022",CityName="Mumbai",CityPopulation="BIG"},
};  
CityPlace[] places = new CityPlace[]{
new CityPlace{CityCode="0771",Place="Shankar Nagar"},
new CityPlace{CityCode="0771",Place="Pandari"},
new CityPlace{CityCode="0771",Place="Energy Park"},
new CityPlace{CityCode="0751",Place="Baadaa"},
new CityPlace{CityCode="0751",Place="Nai Sadak"},
new CityPlace{CityCode="0751",Place="Jayendraganj"},
new CityPlace{CityCode="0751",Place="Vinay Nagar"},
new CityPlace{CityCode="0755",Place="Idgah Hills"},
new CityPlace{CityCode="022",Place="Parel"},
new CityPlace{CityCode="022",Place="Haaji Ali"},
new CityPlace{CityCode="022",Place="Girgaon Beach"},
new CityPlace{CityCode="0783",Place="Railway Station"}
};
var query = 
places.GroupJoin(
cities,
place => place.CityCode,
city => city.CityCode,
( place, matchingCities ) 
=> new {
place,
matchingCities
}
).SelectMany(
groupJoinItem => groupJoinItem.matchingCities.DefaultIfEmpty( new City{ CityName = "NO NAME" } ),
( groupJoinItem, city )
=> new {
Place = groupJoinItem.place,
City = city
}
);              
foreach(var pair in query)
{
Console.WriteLine( pair.Place.Place + ": " + pair.City.CityName );
}
}
class City
{
public string CityCode;
public string CityName;
public string CityPopulation;
}
class CityPlace
{
public string CityCode;
public string Place;
}

Voici le résultat:

Shankar Nagar: Raipur
Pandari: Raipur
Energy Park: Raipur
Baadaa: Gwalior
Nai Sadak: Gwalior
Jayendraganj: Gwalior
Vinay Nagar: Gwalior
Idgah Hills: Bhopal
Parel: Mumbai
Haaji Ali: Mumbai
Girgaon Beach: Mumbai
Railway Station: NO NAME

Avis que le DefaultIfEmpty va renvoyer une nouvelle instance de la Ville proprement dite classe et pas seulement une chaîne de caractères. C'est parce que nous rejoignons le CityPlaces à la Ville des objets, pas des chaînes de caractères. Vous pouvez utiliser DefaultIfEmpty() au lieu de cela, avec aucun paramètre, et vous obtenez un null de la Ville de "la Gare", mais alors il faudrait vérifier, pour les valeurs null dans votre boucle foreach avant l'appel de la paire.Ville.CityName. C'est une question de préférence personnelle.

Voici le même programme à l'aide d'une requête de la compréhension: l'

void Main()
{
City[] cities = new City[]{
new City{CityCode="0771",CityName="Raipur",CityPopulation="BIG"},
new City{CityCode="0751",CityName="Gwalior",CityPopulation="MEDIUM"},
new City{CityCode="0755",CityName="Bhopal",CityPopulation="BIG"},
new City{CityCode="022",CityName="Mumbai",CityPopulation="BIG"},
};  
CityPlace[] places = new CityPlace[]{
new CityPlace{CityCode="0771",Place="Shankar Nagar"},
new CityPlace{CityCode="0771",Place="Pandari"},
new CityPlace{CityCode="0771",Place="Energy Park"},
new CityPlace{CityCode="0751",Place="Baadaa"},
new CityPlace{CityCode="0751",Place="Nai Sadak"},
new CityPlace{CityCode="0751",Place="Jayendraganj"},
new CityPlace{CityCode="0751",Place="Vinay Nagar"},
new CityPlace{CityCode="0755",Place="Idgah Hills"},
new CityPlace{CityCode="022",Place="Parel"},
new CityPlace{CityCode="022",Place="Haaji Ali"},
new CityPlace{CityCode="022",Place="Girgaon Beach"},
new CityPlace{CityCode="0783",Place="Railway Station"}
};
var query = 
from place in places
join city in cities
on place.CityCode equals city.CityCode into matchingCities
from city in matchingCities.DefaultIfEmpty( new City{ CityName = "NO NAME" } )
select new {
Place = place,
City = city
};      
foreach(var pair in query)
{
Console.WriteLine( pair.Place.Place + ": " + pair.City.CityName );
}
}
class City
{
public string CityCode;
public string CityName;
public string CityPopulation;
}
class CityPlace
{
public string CityCode;
public string Place;
}

En tant qu'utilisateur SQL, j'ai beaucoup préfèrent la requête de compréhension de la version. Il est beaucoup plus facile pour quelqu'un d'autre de lire les intention du code une fois que vous savez ce que chacun des éléments de la requête ne.

Bonne programmation!