Programmation .Net - Indépendance financière

Utiliser le Join avec LINQ en C#

Dans cet article nous allons regarder plus en détail le mot-clé join avec Linq en C#. Ce n’est pas plus compliqué qu’un Join en SQL et encore plus puissant, car vous pouvez l’appliquer partout dans le langage plutôt que seulement à la base de données. Par exemple on peut l’utiliser avec XML, SQL, JSon, objets et plus. Pour le moment nous verrons le Linq Join appliqué sur les objets, mais c’est essentiellement la même chose avec les autres.

Qu’est-ce qu’une jointure plus précisément? Vous pouvez faire l’analogie avec le corps humain et les jointures. Elles servent à joindre deux ou plusieurs ensembles. Ce sera très similaire pour les jointures avec LINQ. On joindra plusieurs collections de données ensemble sur des valeurs précises. C’est simple, mais le nombre de possibilités donc plusieurs façons d’avoir le même résultat rend le tout un peu plus complexe à apprendre. Un conseil que je peux donner est d’essayer de trouver la façon la plus simple de faire pour garder la requête précise et facile à lire, même si vous devez en faire plus d’une.

Typiquement avec LINQ, dès que vous effectuerez un “join” standard, vous ferez un inner join. Autrement dit, vous irez chercher ce qu’il y a de commun entre les ensembles de données. Dans cet article nous nous limiterons au inner join et nous verrons aussi le left (outer) join en plus. Ceci par souci de simplicité et parce que ce sont généralement les plus utilisés.

1. Mise en place!

Si vous avez déjà utilisé SQL pour faire des requêtes sur des bases de données, le contenu va très certainement vous sembler familier. Sinon, ce n’est pas grave du tout!

Premièrement créons un projet de type console en utilisant soit le .Net Framework ou encore .Net Core, à votre convenance. Pour ma part j’utiliserai .Net Framework 4.8 pour cet exemple.

Nous allons créer trois collections, puis effectuer des fusions à l’aide du join en une seule contenant seulement les éléments communs pour le Inner join et, pour le Left outer join, les éléments du premier ensemble plus les éléments communs. Deux des trois collections contiendront des objets Car (qui veut dire voiture en français) et la troisième des objets de type Buyer (disons acheteur ou client en français) pour l’exemple du left join. Voici les classes que vous aurez besoin pour ces objets ci-dessous.

Car.cs

namespace TutorialLinqCSharp
{
    public class Car
    {
        public string VIN { get; set; }
        public string Brand { get; set; }
        public string Model { get; set; }

        public override string ToString()
        {
            return $"Vehicle identification number: {VIN}, Brand: {Brand}, Model: {Model}";
        }
    }
}

Buyer.cs

namespace TutorialLinqCSharp
{
    public class Buyer
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public string CarVIN { get; set; }

        public override string ToString()
        {
            return $"Name: {Name}, Age: {Age}, Car VIN: {CarVIN}";
        }
    }
}

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TutorialLinqCSharp
{
    class Program
    {
        static void Main(string[] args)
        {

        }
    }
}

Note: le nom de mon projet est TutorialLinqCSharp, mais le vôtre pourrait être différent donc assurez-vous de changer le namespace pour le nom de votre projet dans les différents fichiers de code.

2. Le inner join

Représentation graphique du Inner Join

Avant de commencer cette partie, voici une représentation graphique du inner join. Comme vous pouvez voir, des deux collections que nous allons joindre, nous prendrons ce qu’il y a de commun selon une propriété en particulier définie dans le ON de notre requête LINQ.

Inner Join

Syntaxe de la requête

Nous sommes maintenant prêts à ajouter les deux collections de tests à notre fichier Program.cs dans la méthode Main. Pour le Inner join, il y aura donc deux collections de type List avec 3 et 4 voitures respectivement, ce qui devrait être suffisant pour notre exemple. Je vous suggère de bien regarder les entrées et ce qui les différencie, car nous les utiliserons dans nos requêtes.

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TutorialLinqCSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            // J'utilise les listes parce qu'elles sont plus faciles à travailler avec.
            List<Car> dealershipInventoryOne = new List<Car>();
            List<Car> dealershipInventoryTwo = new List<Car>();

            // Remplissage du premier inventaire.
            dealershipInventoryOne.Add(new Car() { VIN = "JEQODSM21893211", Brand = "Toyota", Model = "86" });
            dealershipInventoryOne.Add(new Car() { VIN = "JGFFFEE32132134", Brand = "Subaru", Model = "BRZ" });
            dealershipInventoryOne.Add(new Car() { VIN = "JDSAJIS54355432", Brand = "Scion", Model = "FRS" });

            // Remplissage du deuxième inventaire.
            dealershipInventoryTwo.Add(new Car() { VIN = "JQWKOSU32132132", Brand = "Subaru", Model = "BRZ" });
            dealershipInventoryTwo.Add(new Car() { VIN = "JDSOUWE54354444", Brand = "Toyota", Model = "GT86" });
            dealershipInventoryTwo.Add(new Car() { VIN = "JJSOOQU12354567", Brand = "Toyota", Model = "Supra" });
            dealershipInventoryTwo.Add(new Car() { VIN = "JFFDFDS99699488", Brand = "Toyota", Model = "FRS" });
        }
    }
}

La prochaine étape est d’ajouter la requête Linq qui contiendra le join. Gardez en tête que la création de requêtes Linq n’est pas nécessairement un art exact. C’est-à-dire qu’il peut y avoir plusieurs façons d’arriver à la même solution. Ce qui est encore plus vrai lorsque la complexité augmente. Ce que je conseille personnellement est d’essayer de garder le tout le plus simple possible quitte à diviser une requête en deux par exemple.

// Nous effectuons la jointure des deux collections en utilisant le mot-clé join. Le on indique à LINQ quelle sur quelle propriété l'objet "Car"
// sera utilisée pour identifier la similarité entre les voitures. Dans ce cas, ce sera la propriété Model (modèle).
IEnumerable<Car> sameModelCars = from Car inventoryItemOne in dealershipInventoryOne
                                 join Car inventoryItemTwo in dealershipInventoryTwo
                                 on inventoryItemOne.Model
                                 equals inventoryItemTwo.Model
                                 select inventoryItemOne;

Comme vous pouvez le lire dans les commentaires, la requête fait la jointure des deux collections (dealershipInventoryOne et dealershipInventoryTwo) et le résultat contiendra les éléments similaires aux deux, selon ce qu’il y a dans le on, soit le Model. C’est exactement ce que fait un inner join!

Voici le code de mon Program.cs pour la première partie, je vous suggère de l’exécuter pour voir le résultat et de mettre des points d’arrêt.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TutorialLinqCSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            // J'utilise les listes parce qu'elles sont plus faciles à travailler avec.
            List<Car> dealershipInventoryOne = new List<Car>();
            List<Car> dealershipInventoryTwo = new List<Car>();

            // Remplissage du premier inventaire.
            dealershipInventoryOne.Add(new Car() { VIN = "JEQODSM21893211", Brand = "Toyota", Model = "86" });
            dealershipInventoryOne.Add(new Car() { VIN = "JGFFFEE32132134", Brand = "Subaru", Model = "BRZ" });
            dealershipInventoryOne.Add(new Car() { VIN = "JDSAJIS54355432", Brand = "Scion", Model = "FRS" });

            // Remplissage du deuxième inventaire.
            dealershipInventoryTwo.Add(new Car() { VIN = "JQWKOSU32132132", Brand = "Subaru", Model = "BRZ" });
            dealershipInventoryTwo.Add(new Car() { VIN = "JDSOUWE54354444", Brand = "Toyota", Model = "GT86" });
            dealershipInventoryTwo.Add(new Car() { VIN = "JJSOOQU12354567", Brand = "Toyota", Model = "Supra" });
            dealershipInventoryTwo.Add(new Car() { VIN = "JFFDFDS99699488", Brand = "Toyota", Model = "FRS" });

            // Nous effectuons la jointure des deux collections en utilisant le mot-clé join. Le on indique à LINQ quelle propriété de l'objet "Car"
            // sera utilisée pour identifier la similarité entre les voitures. Dans ce cas, ce sera la propriété Model (modèle).
            IEnumerable<Car> sameModelCars = from Car inventoryItemOne in dealershipInventoryOne
                                             join Car inventoryItemTwo in dealershipInventoryTwo
                                             on inventoryItemOne.Model
                                             equals inventoryItemTwo.Model
                                             select inventoryItemOne;

            // Sortie de la collection resultante dans la console!
            OutputCollectionToConsole(sameModelCars);

            // Arrêt de l'exécution de la console.
            Console.ReadKey();
        }

        /// <summary>
        /// Cette méthode sert à effectuer une sortie des elements d'un IEnumerable dans la console en appelant la méthode ToString() de chaque objet. 
        /// </summary>
        /// 
        /// <param name="collectionToOutput">La collection à sortir dans la console.</param>
        private static void OutputCollectionToConsole(IEnumerable<object> collectionToOutput)
        {
            foreach (object collectionItem in collectionToOutput)
                Console.WriteLine(collectionItem.ToString());
        }
    }
}

Décomposition de la requête LINQ

Je sais que j’aurais bien pu présenter un exemple un peu plus simple, toutefois je voulais montrer quelque chose de plus réaliste que de simplement joindre deux listes de nombres (int). Voici maintenant les explications pas-à-pas de la requête que nous venons d’exécuter:

IEnumerable<Car> sameModelCars = from Car inventoryItemOne in dealershipInventoryOne
                                 join Car inventoryItemTwo in dealershipInventoryTwo
                                 on inventoryItemOne.Model
                                 equals inventoryItemTwo.Model
                                 select inventoryItemOne;
  1. Le from Car inventoryItemOne in dealershipInventoryOne indiquera à LINQ que pour chaque instance d’un objet de type Car dans la liste dealershipInventoryOne, d’effectuer le reste des instructions qui créera un résultat.
  2. Pour la suite nous allons joindre la deuxième collection (dealershipInventoryTwo) et dire à LINQ que ces objets seront placés, un à un, dans la variable inventoryItemTwo de type Car elle aussi.
  3. Nous devons spécifier sur quelle propriété ces deux ensembles seront joints dans le on. Ceci indiquera à LINQ quel est la propriété qui déterminera si deux objets sont semblablent donc dans section du millieu en rouge du graphique plus haut. Dans notre cas, ce sera le Model que nous utiliserons. Si nous regardons les deux collections plus haut et que nous cherchons les modèles communs alors dans la partie du centre du graphique, nous devrions retrouver BRZ et FRS.
  4. Finalement, le select indiquera à LINQ quels objets mettre dans notre résultat, dans ce cas, une variable de type IEnumerable. Vous pouvez constater que ce sera l’objet complet inventoryItemOne, de type Car. Toutefois, nous pourrions aller chercher précisément une propriété comme inventoryItemOne.Make. Dans ce cas nous devrions changer le type de notre collection de retour en accordance avec le type de Make soit, IEnumerable.

Note: avec LINQ, vous devez utiliser le mot-clé equals pour spécifier l’égaliter et non ==.

Voici la sortie dans la console ci-dessous.

Inner join equals, output in console.

Variante du Inner join avec un autre select

Remarquez que l’objet montré dans la console est en fait un élément provenant de dealershipInventoryOne. L’explication est que dans le select de la requête, nous avons pris inventoryItemOne. Prenons inventoryItemTwo à la place et voyons le résultat. Vous pouvez remplacer la requête LINQ en haut par celle qui suit et voyez que maintenant un élément dans la deuxième liste a été sélectionné.

IEnumerable<Car> sameModelCars = from Car inventoryItemOne in dealershipInventoryOne
                                 join Car inventoryItemTwo in dealershipInventoryTwo
                                 on inventoryItemOne.Model equals inventoryItemTwo.Model
                                 select inventoryItemTwo;

Voici la sortie dans la console.

Output from the Console with InventoryItemTwo selected.

Donc vous avez le choix de ce que vous voulez sélectionner et vous pouvez spécifier ceci dans la portion select de la requête. Je n’irai pas plus en détail parce que j’en traiterai dans un article futur. Il me reste une dernière chose que j’aimerais montrer avant de passer au Left join.

Inner join sur plusieurs valeurs

Disons que nous souhaitons effectuer une jointure sur plus que seulement la propriété Model. Nous pourrions ajouter la marque soit la propriété Brand aussi. Dans ce cas, nous voulons que les éléments de la collections résultante de la jointure aient leur marque et leur modèle en commun. Rappelez-vous la structure du inner join plus haut. Pour ce faire, nous devrons modifier la section on de la requête LINQ.

IEnumerable<Car> sameModelCars = from Car inventoryItemOne in dealershipInventoryOne
                                 join Car inventoryItemTwo in dealershipInventoryTwo
                                 on new { inventoryItemOne.Model, inventoryItemOne.Brand }
                                    equals new { inventoryItemTwo.Model, inventoryItemTwo.Brand }
                                 select inventoryItemTwo;

Maintenant c’est encore plus précis que ce que nous avions précédemment et uniquement la Subaru BRZ apparaîtra. Avant nous pouvions voir la Toyota FRS et la Scion FRS qui avaient le même modèle mais pas la même marque. Pour avoir l’égalité nous devrons donc avoir la marque et le modèle de similaire et seulement les éléments des deux collections qui répondent à ce critère seront dans l’ensemble résultant.

Output from the Console.

3. Le Left outer join

Qu’as l’air le Left join

Left Join

Comme vous pouvez le constater, nous prenons des deux collections, la même chose que le inner join en plus de tout ce qu’il y a dans le premier ensemble même s’il n’y a pas de similarités dans le deuxième pour ces éléments. Vous comprendrez mieux dans l’exemple qui suit.

Syntaxe

Le Left outer join est un peu plus compliqué que le inner join mais peut être utile dans certaines situations spécifiques. Ce qu’on doit se rappeler est que nous prendrons tout les éléments de la première collection plus ceux qui sont communs avec la deuxième comme mentionné ci-dessus. De plus, si la deuxième collection a des propriétés qui ne sont pas incluses dans la première, ils seront remplacés par null, un peu comme avec SQL.

Pour le left outer join, nous allons ajouter les acheteurs (buyers) de qui nous avons récolté le VIN de leur voiture respective. J’ai créé la liste suivante.

List<Buyer> carBuyers = new List<Buyer>();
carBuyers.Add(new Buyer() { Name = "Bob", Age = 42, CarVIN = "AASDSAD12222213" });
carBuyers.Add(new Buyer() { Name = "Roger", Age = 27, CarVIN = "DSADSAD12222213" });
carBuyers.Add(new Buyer() { Name = "Alex", Age = 30, CarVIN = "JGFFFEE32132134" });
carBuyers.Add(new Buyer() { Name = "Sofia", Age = 36, CarVIN = "JDSAJIS54355432" });

Je suggère que nous commencions par faire exactement le processus comme si nous voulions faire un inner join. Je veux donc joindre les acheteurs (Buyer) et les voitures (Car) sur le VIN. De plus, comme vous avez sûrement remarqué, certains VIN appartenant aux buyers ne sont pas présent dans l’inventaire de voiture que nous allons joindre (dealershipInventoryOne).

Console.WriteLine("----Inner Join With Buyers----");

// Ajout des acheteurs qui on une voiture, nous voulons savoir si des acheteurs on une voiture avec la plateform 86 se trouvant dans l'inventaire 1 (dealershipInventoryOne).
List<Buyer> carBuyers = new List<Buyer>();
carBuyers.Add(new Buyer() { Name = "Bob", Age = 42, CarVIN = "AASDSAD12222213" });
carBuyers.Add(new Buyer() { Name = "Roger", Age = 27, CarVIN = "DSADSAD12222213" });
carBuyers.Add(new Buyer() { Name = "Alex", Age = 30, CarVIN = "JGFFFEE32132134" });
carBuyers.Add(new Buyer() { Name = "Sofia", Age = 36, CarVIN = "JDSAJIS54355432" });

var buyersWithCarInner = from Buyer buyer in carBuyers
                    join Car inventoryItemOn in dealershipInventoryOne
                    on buyer.CarVIN equals inventoryItemOn.VIN
                    select new
                    {
                        Buyer = buyer,
                        Car = inventoryItemOn
                    };

// On montre l'acheteur et sa voiture dans la console.
foreach(var buyerWithCarInner in buyersWithCarInner)
    Console.WriteLine($"Buyer: {buyerWithCarInner.Buyer.ToString()}, Car: {buyerWithCarInner.Car.ToString()}");

Ne laissez pas le select new vous décourager, je crée simplement un nouveau type d’objet anonyme qui contiendra l’acheteur (Buyer) et sa voiture associée (Car) comme propriétés.

Voici la sortie dans la console après avoir ajouté les deux morceaux de code suivants au Program.cs.

Left join without grouping.

Ouin, ça c’est un inner join! Pas exactement ce qu’on veut, mais une partie de fait. On a donc uniquement les acheteurs avec une voiture si il y a un VIN correspondant dans l’inventaire. Ce n’est pas ce que nous voulons parce que le left join doit retourner tous les éléments de l’ensemble de gauche qu’ils aient ou non un élément correspondant sur le on dans l’ensemble de droite. Modifions la requête un peu.

Créons un vrai Left outer join!

Remplacez la requête que nous venons de créer par le code suivant dans votre Program.cs. Nous devons faire des groupes pour avoir des null sur les valeurs de VIN qui n’existent pas dans l’inventaire.

Console.WriteLine("----Left Outer Join avec les acheteurs----");

// Left outer join appliqué sur la requête LINQ.
var buyersWithCar = from Buyer buyer in carBuyers
                    join Car inventoryItemOn in dealershipInventoryOne
                    on buyer.CarVIN equals inventoryItemOn.VIN
                    into carGroup
                    from groupedCar in carGroup.DefaultIfEmpty(new Car()
                    {
                        VIN = buyer.CarVIN,
                        Brand = "Unknown",
                        Model = "Unknown"
                    })
                    select new
                    {
                        Buyer = buyer,
                        Car = groupedCar
                    };

// La voiture peut être null (ou dans ce cas le Default que nous avons appliqué dans DefaultIfEmpty) si le VIN de l'acheteur ne correspond à aucune voiture dans dealershipInventoryOne.
foreach (var buyerWithCar in buyersWithCar)
    Console.WriteLine($"Buyer: {buyerWithCar.Buyer.ToString()}, Car: {buyerWithCar.Car.ToString()}");

Je souhaite attirer votre attention sur la ligne into carGroup soit la création d’un groupe de voitures pour un acheteur. Dans notre exemple, nous avons uniquement une voiture possible lors de la jointure car un client a seulement une voiture. Toutefois on pourrait modifier le code pour qu’un client puisse avoir plus d’une voiture. Nous resterons quand même avec soit zéro ou une voiture en common entre le client et l’inventaire (dealershipInventoryOne) pour cet exemple.

Décomposition de la requête LINQ

  1. Nous commençons par aller chercher l’objet acheteur dans la liste carBuyers.
  2. Ensuite, tout comme avec le inner join, nous effectuons la jointure de dealershipInventoryOne sur le VIN de l’acheteur et de l’inventaire.
  3. Donc pour chaque acheteur et voiture joints sur leur VIN, LINQ créera un groupe contenant respectivement les deux objets. Le groupe s’appellera carGroup. Il pourrait techniquement contenir plus d’une voiture puisque c’est un groupe mais pas dans notre cas puisqu’un acheteur n’a qu’un VIN.
  4. Ensuite pour chacune des voitures dans le groupe correspondant à l’acheteur, LINQ va soit laissé l’objet comme tel ou créer un nouvel objet de type Car vide s’il n’y a pas de correspondant (ou s’il est null). C’est fait par la méthode DefaultIfEmpty.
  5. L’objet final ira dans la collection retournée buyersWithCar et sera composé de l’acheteur et de la voiture qui lui est liée. Remarquez que j’utilise Var comme type de retour car le select est un objet anonyme créer par LINQ au moment de l’exécution donc n’a pas de type défini. .

Je vous conseille très fortement d’expérimenter avec le code pour vous aider à comprendre, vous pouvez mettre des points d’arrêt ou même changer la requête pour en voir le résultat.

Voici la sortie de la requête précédente dans la console.

Left Outer Join Console Output.

Code complet de Program.cs

using System;
using System.Collections.Generic;
using System.Linq;

namespace TutorialLinqCSharp
{
    class Program
    {
        static void Main(string[] args)
        {
            // J'utilise les listes parce qu'elles sont plus faciles à travailler avec.
            List<Car> dealershipInventoryOne = new List<Car>();
            List<Car> dealershipInventoryTwo = new List<Car>();

            // Remplissage du premier inventaire.
            dealershipInventoryOne.Add(new Car() { VIN = "JEQODSM21893211", Brand = "Toyota", Model = "86" });
            dealershipInventoryOne.Add(new Car() { VIN = "JGFFFEE32132134", Brand = "Subaru", Model = "BRZ" });
            dealershipInventoryOne.Add(new Car() { VIN = "JDSAJIS54355432", Brand = "Scion", Model = "FRS" });

            // Remplissage du deuxième inventaire.
            dealershipInventoryTwo.Add(new Car() { VIN = "JQWKOSU32132132", Brand = "Subaru", Model = "BRZ" });
            dealershipInventoryTwo.Add(new Car() { VIN = "JDSOUWE54354444", Brand = "Toyota", Model = "GT86" });
            dealershipInventoryTwo.Add(new Car() { VIN = "JJSOOQU12354567", Brand = "Toyota", Model = "Supra" });
            dealershipInventoryTwo.Add(new Car() { VIN = "JFFDFDS99699488", Brand = "Toyota", Model = "FRS" });

            Console.WriteLine("----Inner Join----");

            // Nous effectuons la jointure des deux collections en utilisant le mot-clé join. Le on indique à LINQ quelle propriété de l'objet "Car"
            // sera utilisée pour identifier la similarité entre les voitures. Dans ce cas, ce sera la propriété Model (modèle).
            IEnumerable<Car> sameModelCars = from Car inventoryItemOne in dealershipInventoryOne
                                             join Car inventoryItemTwo in dealershipInventoryTwo
                                             on new { inventoryItemOne.Model }
                                                equals new { inventoryItemTwo.Model }
                                             select inventoryItemTwo;

            // Sortie de la collection resultante dans la console!
            OutputCollectionToConsole(sameModelCars);

            Console.WriteLine("----Inner Join With Buyers----");

            // Ajout des acheteurs qui on une voiture, nous voulons savoir si des acheteurs on une voiture avec la plateform 86 se trouvant dans l'inventaire 1 (dealershipInventoryOne).
            List<Buyer> carBuyers = new List<Buyer>();
            carBuyers.Add(new Buyer() { Name = "Bob", Age = 42, CarVIN = "AASDSAD12222213" });
            carBuyers.Add(new Buyer() { Name = "Roger", Age = 27, CarVIN = "DSADSAD12222213" });
            carBuyers.Add(new Buyer() { Name = "Alex", Age = 30, CarVIN = "JGFFFEE32132134" });
            carBuyers.Add(new Buyer() { Name = "Sofia", Age = 36, CarVIN = "JDSAJIS54355432" });

            var buyersWithCarInner = from Buyer buyer in carBuyers
                                     join Car inventoryItemOn in dealershipInventoryOne
                                     on buyer.CarVIN equals inventoryItemOn.VIN
                                     select new
                                     {
                                         Buyer = buyer,
                                         Car = inventoryItemOn
                                     };

            foreach (var buyerWithCarInner in buyersWithCarInner)
                Console.WriteLine($"Buyer: {buyerWithCarInner.Buyer.ToString()}, Car: {buyerWithCarInner.Car.ToString()}");

            Console.WriteLine("----Left Outer Join With Buyers----");

            // Left outer join appliqué sur la requête LINQ.
            var buyersWithCar = from Buyer buyer in carBuyers
                                join Car inventoryItemOn in dealershipInventoryOne
                                on buyer.CarVIN equals inventoryItemOn.VIN
                                into carGroup
                                from groupedCar in carGroup.DefaultIfEmpty(new Car()
                                {
                                    VIN = buyer.CarVIN,
                                    Brand = "Unknown",
                                    Model = "Unknown"
                                })
                                select new
                                {
                                    Buyer = buyer,
                                    Car = groupedCar
                                };

            // La voiture peut être null (ou dans ce cas le Default que nous avons appliqué dans DefaultIfEmpty) si le VIN de l'acheteur ne correspond à aucune voiture dans dealershipInventoryOne.
            foreach (var buyerWithCar in buyersWithCar)
                Console.WriteLine($"Buyer: {buyerWithCar.Buyer.ToString()}, Car: {buyerWithCar.Car.ToString()}");

            // Arrêt de l'exécution de la console.
            Console.ReadKey();
        }

        /// <summary>
        /// Cette méthode sert à effectuer une sortie des elements d'un IEnumerable dans la console en appelant la méthode ToString() de chaque objet. 
        /// </summary>
        /// 
        /// <param name="collectionToOutput">La collection à sortir dans la console.</param>
        private static void OutputCollectionToConsole(IEnumerable<object> collectionToOutput)
        {
            foreach (object collectionItem in collectionToOutput)
                Console.WriteLine(collectionItem.ToString());
        }
    }
}

Pourquoi je ne montre pas plus de types de jointures?

Disons que c’est surtout pour essayer de garder les tutoriels assez simples et courts. De plus, vous verrez qu’il y a d’autres méthodes avec LINQ comme le Union et le Except qui peuvent faire des opérations de base qui nécessitent beaucoup plus de code en SQL pour arriver au même résultat par exemple. En effet, ces différents mots-clés sont vraiment puissants et pourront vous aider à réduire le nombre de lignes et la complexité de votre code tout comme les jointures que j’ai montrées dans cet article. Finalement, je pense que le left join et le inner join devraient être suffisants dans la grande majorité des cas sans que l’on ait à regarder d’autres types de jointures.

Si vous avez besoin de plus d’information sur le Join avec LINQ, vous pouvez vous référer au site de Microsoft Docs. Même chose si vous voulez plus d’information sur l’utilisation des groups avec LINQ!

Bon code!

Vous avez trouvé un bogue dans mon code? C’est possible, veuillez m’envoyer un message en utilisant mon formulaire de contact pour que je puisse remédier à la situation aussi rapidement que possible!

YouTube

Le inner join

Next article Accéder aux fichiers avec le FileStream en C#/Visual Basic
Previous article Requêtes sur les données relationnelles avec Linq/Entity Framework en C#

Related posts

0 Comments

No Comments Yet!

You can be first to comment this post!

Leave a Comment

Your data will be safe! Your e-mail address will not be published. Also other data will not be shared with third person. Required fields marked as *