Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. Syntaxe de requête C# LINQ Join
.NET AIDE

C# LINQ Join Query Syntax (Comment ça fonctionne pour les développeurs)

Curtis Chau
Curtis Chau
Mis à jour:

Dans la polyvalence de la programmation C#, LINQ (Language Integrated Query) se distingue comme un outil puissant pour interroger et manipuler des collections d'objets. Parmi les nombreux opérateurs offerts par LINQ, l'opérateur Join est un acteur clé lorsqu'il s'agit de fusionner des données provenant de plusieurs sources.

Dans cet article, nous explorerons en profondeur les complexités de l'opérateur Join de C# LINQ, en dévoilant ses fonctionnalités, sa syntaxe et ses applications dans le monde réel.

Comprendre les bases de la clause Join

Au cœur, l'opérateur Join de LINQ est conçu pour combiner des éléments de deux ou plusieurs collections en fonction d'une condition spécifiée. Cet opérateur permet aux développeurs d'effectuer des jointures de type SQL sur des collections en mémoire, facilitant ainsi la fusion de données de sources disparates avec facilité.

Syntaxe de l'opérateur Join de LINQ

La syntaxe de l'opérateur Join de LINQ est expressive et suit un schéma qui ressemble aux jointures SQL. La syntaxe de base est la suivante :

var queryResult = 
    from element1 in collection1
    join element2 in collection2 on element1.Key equals element2.Key
    select new { element1, element2 };
var queryResult = 
    from element1 in collection1
    join element2 in collection2 on element1.Key equals element2.Key
    select new { element1, element2 };
Dim queryResult = From element1 In collection1
	Join element2 In collection2 On element1.Key Equals element2.Key
	Select New With {
		Key element1,
		Key element2
	}
$vbLabelText   $csharpLabel

Dans cette syntaxe :

  • element1 et element2 sont des variables représentant des éléments de collection1 et collection2.
  • element1.Key et element2.Key sont les propriétés utilisées comme base pour l'opération de jointure.
  • Le mot-clé equals spécifie la condition pour la jointure.
  • La clause select crée un nouvel objet qui combine des éléments des deux collections.

Types de Join LINQ

LINQ prend en charge plusieurs types de jointures, y compris :

  1. Inner Join : Retourne uniquement les éléments dont les clés correspondent dans les deux collections.

    var innerJoin = from customer in customers
                join order in orders on customer.CustomerID equals order.CustomerID // join orders to customers based on the customer ID key
                select new { customer.CustomerID, customer.CustomerName, order.OrderID }; // create a new anonymous object based on the objects obtained from the join
    var innerJoin = from customer in customers
                join order in orders on customer.CustomerID equals order.CustomerID // join orders to customers based on the customer ID key
                select new { customer.CustomerID, customer.CustomerName, order.OrderID }; // create a new anonymous object based on the objects obtained from the join
    Dim innerJoin = From customer In customers ' create a new anonymous object based on the objects obtained from the join
	Join order In orders On customer.CustomerID Equals order.CustomerID
	Select New With {
		Key customer.CustomerID,
		Key customer.CustomerName,
		Key order.OrderID
	}
    $vbLabelText   $csharpLabel

  2. Left Outer Join (par défaut) : Retourne tous les éléments de la collection de gauche et les éléments correspondants de la collection de droite. Si aucune correspondance n'est trouvée, le résultat contiendra la valeur par défaut pour les éléments de droite.

    var leftOuterJoin = from customer in customers
                    join order in orders on customer.CustomerID equals order.CustomerID into customerOrders
                    from co in customerOrders.DefaultIfEmpty()
                    select new { customer.CustomerID, customer.CustomerName, OrderID = co?.OrderID ?? -1 };
    var leftOuterJoin = from customer in customers
                    join order in orders on customer.CustomerID equals order.CustomerID into customerOrders
                    from co in customerOrders.DefaultIfEmpty()
                    select new { customer.CustomerID, customer.CustomerName, OrderID = co?.OrderID ?? -1 };
    Dim leftOuterJoin = From customer In customers
	Group Join order In orders On customer.CustomerID Equals order.CustomerID Into customerOrders = Group
	From co In customerOrders.DefaultIfEmpty()
	Select New With {
		Key customer.CustomerID,
		Key customer.CustomerName,
		Key .OrderID = If(co?.OrderID, -1)
	}
    $vbLabelText   $csharpLabel

  3. Group Join : Regroupe les éléments de la collection de gauche avec les éléments correspondants de la collection de droite.

    var groupJoin = from customer in customers
                join order in orders on customer.CustomerID equals order.CustomerID into customerOrders
                select new { customer.CustomerID, customer.CustomerName, Orders = customerOrders };
    var groupJoin = from customer in customers
                join order in orders on customer.CustomerID equals order.CustomerID into customerOrders
                select new { customer.CustomerID, customer.CustomerName, Orders = customerOrders };
    Dim groupJoin = From customer In customers
	Group Join order In orders On customer.CustomerID Equals order.CustomerID Into customerOrders = Group
	Select New With {
		Key customer.CustomerID,
		Key customer.CustomerName,
		Key .Orders = customerOrders
	}
    $vbLabelText   $csharpLabel

Application dans le monde réel : Combinaison de données client et de commande

Prenons un exemple pratique où nous disposons de deux collections : clients et commandes. Nous voulons créer un ensemble de résultats qui combine les informations client avec leurs commandes correspondantes à l'aide de l'opérateur Join de LINQ.

var customerOrderInfo = 
    from customer in customers
    join order in orders on customer.CustomerID equals order.CustomerID
    select new { customer.CustomerID, customer.CustomerName, order.OrderID, order.OrderDate };
var customerOrderInfo = 
    from customer in customers
    join order in orders on customer.CustomerID equals order.CustomerID
    select new { customer.CustomerID, customer.CustomerName, order.OrderID, order.OrderDate };
Dim customerOrderInfo = From customer In customers
	Join order In orders On customer.CustomerID Equals order.CustomerID
	Select New With {
		Key customer.CustomerID,
		Key customer.CustomerName,
		Key order.OrderID,
		Key order.OrderDate
	}
$vbLabelText   $csharpLabel

Dans cet exemple, l'ensemble de résultats contiendra des entrées avec les informations du client ainsi que leurs commandes associées. La syntaxe de méthode d'extension de jointure aide les développeurs C# à effectuer des opérations de jointure de type SQL.

Présentation d'IronPDF

Syntaxe de requête Join LINQ de C# (Comment cela fonctionne pour les développeurs) : Figure 1 - Page web IronPDF

Développez des solutions PDF avec IronPDF est une bibliothèque complète pour C# conçue pour créer, traiter et modifier des documents PDF. Elle permet aux développeurs de générer dynamiquement des PDF à partir de diverses sources de données, en constituant une solution polyvalente pour les applications nécessitant la génération de documents PDF.

Installer IronPDF : Un démarrage rapide

Pour commencer à utiliser la bibliothèque IronPDF dans votre projet C#, vous pouvez facilement installer le package NuGet IronPDF. Utilisez la commande suivante dans votre Console du Gestionnaire de Packages :

Install-Package IronPdf

Alternativement, vous pouvez rechercher "IronPDF" dans le gestionnaire de packages NuGet et l'installer à partir de là.

Syntaxe de requête Join LINQ de C# (Comment cela fonctionne pour les développeurs) : Figure 2 - Installation de la bibliothèque IronPDF depuis le gestionnaire de paquets NuGet

Join LINQ et IronPDF : Un duo dynamique ?

L'opérateur Join de LINQ, reconnu pour sa capacité à fusionner des données de sources disparates, peut être un atout précieux dans des scénarios où l'intégration des données est essentielle. Lorsqu'il s'agit d'utiliser le Join de LINQ avec IronPDF, la principale considération porte sur la nature des données que vous souhaitez intégrer au document PDF.

Le point fort de IronPDF est sa fonction Conversion HTML en PDF, qui préserve vos mises en page et styles. Cette fonctionnalité permet la génération de PDF à partir de contenu web, parfaite pour les rapports, factures et documentations. Les fichiers HTML, les URLs et les chaînes HTML peuvent être convertis en PDFs sans problème.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Scénario 1 : Combinaison de données avant la génération de PDF

Si votre objectif est de combiner des données de différentes sources avant d'initier le processus de génération de PDF, Join de LINQ peut être utilisé indépendamment. Une fois que vous disposez d'un ensemble de données unifié, vous pouvez utiliser IronPDF pour générer dynamiquement un document PDF basé sur les données intégrées.

Voici un exemple simplifié :

// Assume 'customerOrderInfo' is a result set obtained using LINQ Join
var pdfDocument = new IronPdf.ChromePdfRenderer();
foreach (var entry in customerOrderInfo)
{
    // Use IronPDF to add content to the PDF based on integrated data
    pdfDocument.AddHTML($"<p>Customer ID: {entry.CustomerID}, Order ID: {entry.OrderID}</p>");
}
// Save or render the PDF document as needed
pdfDocument.SaveAs("IntegratedDataDocument.pdf");
// Assume 'customerOrderInfo' is a result set obtained using LINQ Join
var pdfDocument = new IronPdf.ChromePdfRenderer();
foreach (var entry in customerOrderInfo)
{
    // Use IronPDF to add content to the PDF based on integrated data
    pdfDocument.AddHTML($"<p>Customer ID: {entry.CustomerID}, Order ID: {entry.OrderID}</p>");
}
// Save or render the PDF document as needed
pdfDocument.SaveAs("IntegratedDataDocument.pdf");
' Assume 'customerOrderInfo' is a result set obtained using LINQ Join
Dim pdfDocument = New IronPdf.ChromePdfRenderer()
For Each entry In customerOrderInfo
	' Use IronPDF to add content to the PDF based on integrated data
	pdfDocument.AddHTML($"<p>Customer ID: {entry.CustomerID}, Order ID: {entry.OrderID}</p>")
Next entry
' Save or render the PDF document as needed
pdfDocument.SaveAs("IntegratedDataDocument.pdf")
$vbLabelText   $csharpLabel

Découvrez plus de façons de générer des documents PDF et comment vous pouvez utiliser le Join de LINQ avec IronPDF en visitant la Documentation IronPDF.

Scénario 2 : Intégration de données dynamique pendant la génération de PDF

IronPDF permet l'ajout dynamique de contenu aux documents PDF, rendant possible l'intégration de données en utilisant Join de LINQ pendant le processus même de génération de PDF. Ici, nous allons créer et organiser la classe client pour représenter l'application dans le monde réel. Les sources de données peuvent être une base de données SQL ou un format structuré, dans ce cas, une liste d'objets contenant un ensemble d'attributs de données, tout comme des tables dans la base de données. L'exemple suivant montre une intégration détaillée de la méthode Join de LINQ avec IronPDF alors que nous utilisons des chaînes HTML pour la génération de PDF afin de créer le document :

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

class Order
{
    public int OrderID { get; set; }
    public int CustomerID { get; set; }
    // Other order-related properties...
}

class Customer
{
    public int CustomerID { get; set; }
    // Other customer-related properties...
}

class Program
{
    static void Main()
    {
        // Sample orders collection
        var orders = new List<Order>
        {
            new Order { OrderID = 1, CustomerID = 1 },
            new Order { OrderID = 2, CustomerID = 1 },
            new Order { OrderID = 3, CustomerID = 2 },
        };

        // Sample customers collection
        var customers = new List<Customer>
        {
            new Customer { CustomerID = 1 },
            new Customer { CustomerID = 2 },
        };

        var pdfDocument = new ChromePdfRenderer();
        string htmlContent = "<h1>Details generated using LINQ JOIN</h1>";

        // Use join to find customer orders
        var query = from customer in customers
                    join order in orders on customer.CustomerID equals order.CustomerID
                    select new { CustomerID = customer.CustomerID, OrderID = order.OrderID };

        foreach (var result in query)
        {
            // Use IronPDF to dynamically add content to the PDF based on integrated data
            htmlContent += $"<p>Customer ID: {result.CustomerID}, Order ID: {result.OrderID}</p>";
        }

        // Save or render the PDF document as needed
        pdfDocument.RenderHtmlAsPdf(htmlContent)
                   .SaveAs("DynamicIntegratedDataDocument.pdf");
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using IronPdf;

class Order
{
    public int OrderID { get; set; }
    public int CustomerID { get; set; }
    // Other order-related properties...
}

class Customer
{
    public int CustomerID { get; set; }
    // Other customer-related properties...
}

class Program
{
    static void Main()
    {
        // Sample orders collection
        var orders = new List<Order>
        {
            new Order { OrderID = 1, CustomerID = 1 },
            new Order { OrderID = 2, CustomerID = 1 },
            new Order { OrderID = 3, CustomerID = 2 },
        };

        // Sample customers collection
        var customers = new List<Customer>
        {
            new Customer { CustomerID = 1 },
            new Customer { CustomerID = 2 },
        };

        var pdfDocument = new ChromePdfRenderer();
        string htmlContent = "<h1>Details generated using LINQ JOIN</h1>";

        // Use join to find customer orders
        var query = from customer in customers
                    join order in orders on customer.CustomerID equals order.CustomerID
                    select new { CustomerID = customer.CustomerID, OrderID = order.OrderID };

        foreach (var result in query)
        {
            // Use IronPDF to dynamically add content to the PDF based on integrated data
            htmlContent += $"<p>Customer ID: {result.CustomerID}, Order ID: {result.OrderID}</p>";
        }

        // Save or render the PDF document as needed
        pdfDocument.RenderHtmlAsPdf(htmlContent)
                   .SaveAs("DynamicIntegratedDataDocument.pdf");
    }
}
Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports IronPdf

Friend Class Order
	Public Property OrderID() As Integer
	Public Property CustomerID() As Integer
	' Other order-related properties...
End Class

Friend Class Customer
	Public Property CustomerID() As Integer
	' Other customer-related properties...
End Class

Friend Class Program
	Shared Sub Main()
		' Sample orders collection
		Dim orders = New List(Of Order) From {
			New Order With {
				.OrderID = 1,
				.CustomerID = 1
			},
			New Order With {
				.OrderID = 2,
				.CustomerID = 1
			},
			New Order With {
				.OrderID = 3,
				.CustomerID = 2
			}
		}

		' Sample customers collection
		Dim customers = New List(Of Customer) From {
			New Customer With {.CustomerID = 1},
			New Customer With {.CustomerID = 2}
		}

		Dim pdfDocument = New ChromePdfRenderer()
		Dim htmlContent As String = "<h1>Details generated using LINQ JOIN</h1>"

		' Use join to find customer orders
		Dim query = From customer In customers
			Join order In orders On customer.CustomerID Equals order.CustomerID
			Select New With {
				Key .CustomerID = customer.CustomerID,
				Key .OrderID = order.OrderID
			}

		For Each result In query
			' Use IronPDF to dynamically add content to the PDF based on integrated data
			htmlContent &= $"<p>Customer ID: {result.CustomerID}, Order ID: {result.OrderID}</p>"
		Next result

		' Save or render the PDF document as needed
		pdfDocument.RenderHtmlAsPdf(htmlContent).SaveAs("DynamicIntegratedDataDocument.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Ce code utilise le mot-clé join qui aide à trouver les commandes correspondantes pour chaque client, rendant la requête plus concise et expressive.

Syntaxe de requête Join LINQ de C# (Comment cela fonctionne pour les développeurs) : Figure 3 - PDF généré à partir de l'exemple de code précédent

Conclusion

En conclusion, IronPDF sert de solution robuste pour la génération de PDF dans les applications C#. Lorsqu'il est combiné avec le puissant opérateur Join de LINQ, les développeurs peuvent réaliser une intégration de données fluide avant ou pendant le processus de génération de PDF. Que vous ayez besoin de combiner des informations de clients avec des commandes ou de fusionner des données de sources diversifiées, le duo dynamique du Join de LINQ et d'IronPDF offre une approche flexible et efficace pour améliorer vos capacités de génération de PDF dans les applications C#.

En conclusion, l'opérateur Join de C# LINQ est un outil formidable pour intégrer de manière transparente des données provenant de plusieurs sources. Que vous traitiez des bases de données, des réponses d'API ou des collections en mémoire, l'opérateur Join de LINQ simplifie le processus de combinaison des données en fonction de conditions spécifiées. Alors que vous naviguez dans le paysage diversifié des connexions de données dans vos applications C#, considérez la puissance et la flexibilité que l'opérateur Join de LINQ apporte à votre trousse à outils d'intégration de données. Maîtriser cet opérateur ouvre de nouvelles possibilités pour travailler efficacement avec et manipuler des données, améliorant les capacités de vos applications C#.

IronPDF offre une version d'essai gratuite à des fins d'évaluation pour tester ses fonctionnalités complètes. Cependant, il doit être correctement licencié une fois la période d'essai expirée.

Questions Fréquemment Posées

Quel est le but de l'opérateur C# LINQ Join ?

L'opérateur C# LINQ Join est conçu pour fusionner les données de plusieurs collections en fonction d'une condition spécifiée. Il permet aux développeurs d'effectuer des intégrations de données complexes similaires aux jointures SQL, ce qui le rend inestimable pour la manipulation des données en mémoire.

Comment puis-je convertir HTML en PDF en C# ?

Vous pouvez utiliser la méthode RenderHtmlAsPdf d'IronPDF pour convertir des chaînes HTML en PDFs. Vous pouvez également convertir des fichiers HTML en PDFs en utilisant RenderHtmlFileAsPdf.

Quels types d'accords sont pris en charge par LINQ ?

LINQ prend en charge plusieurs types de jointures, y compris Inner Join, Left Outer Join et Group Join. Ces types de jointures permettent différents niveaux d'intégration de données, tels que le retour uniquement des éléments correspondants ou l'inclusion de tous les éléments d'une collection source.

Comment peut-on appliquer LINQ Join dans un scénario réel ?

LINQ Join peut être utilisé dans des scénarios réels pour fusionner des données provenant de différentes sources, telles que la combinaison d'informations client avec leurs données de commande. Cette intégration facilite une analyse de données et des rapports complets.

Comment puis-je installer une bibliothèque C# pour la génération de PDF dans mon projet ?

Vous pouvez installer IronPDF dans votre projet C# via le Gestionnaire de packages NuGet en utilisant la commande Install-Package IronPdf dans la console du gestionnaire de packages ou en recherchant 'IronPDF' dans le gestionnaire de packages NuGet.

Quels sont les avantages d'utiliser une bibliothèque de génération de PDF en C# ?

L'utilisation d'une bibliothèque telle qu'IronPDF permet une génération dynamique de PDF à partir de diverses sources de données, tout en conservant la mise en page et les styles du contenu. Il est particulièrement utile pour convertir du contenu HTML en PDF pour créer des rapports, des factures et d'autres documents.

Comment LINQ Join et une bibliothèque de génération de PDF peuvent-ils travailler ensemble ?

Vous pouvez utiliser LINQ Join pour intégrer des données de diverses sources, puis générer un PDF à l'aide d'IronPDF. Cette combinaison permet de créer des documents PDF dynamiques basés sur des ensembles de données complets et intégrés.

Puis-je utiliser LINQ Join lors du processus de génération de PDF ?

Oui, vous pouvez utiliser LINQ Join pour intégrer des données lors de la génération d'un PDF avec IronPDF. Cela permet la création de documents dynamiques pouvant refléter l'intégration des données en temps réel, améliorant à la fois l'efficacité et la flexibilité de la création de documents.

Quelles fonctionnalités offre la conversion de HTML en PDF ?

La fonctionnalité de conversion HTML en PDF d'IronPDF vous permet de convertir des fichiers HTML, des URL et des chaînes HTML en PDF tout en préservant la mise en page et le style. Cela est particulièrement utile pour générer des documents PDF visuellement cohérents à partir de contenu Web.

Existe-t-il une option d'évaluation disponible pour une bibliothèque de génération de PDF ?

Oui, IronPDF propose un essai gratuit à des fins d'évaluation. Une licence appropriée est requise pour une utilisation continue au-delà de la période d'essai pour accéder à l'ensemble des fonctionnalités de la bibliothèque.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit