.NET HELP

C# LINQ Join Query Syntax (How It Works For Developers)

Published February 18, 2024

In the versatility of C# programming, LINQ (Language Integrated Query) stands out as a powerful tool for querying and manipulating collections of objects. Among the numerous operators LINQ offers, the Join operator is a key player when it comes to merging data from multiple sources.

In this article, we'll dive deep into the complexities of the C# LINQ Join operator, unraveling its functionality, syntax, and real-world applications.

Understanding the Basics of Join Clause

At its core, the LINQ Join operator is designed to combine elements from two or more collections based on a specified condition. This operator enables developers to perform SQL-like joins on in-memory collections, facilitating the merging of data from disparate sources with ease.

Syntax of the LINQ Join Operator

The syntax for the LINQ Join operator is expressive and follows a pattern that resembles SQL joins. The basic syntax is as follows:

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
	}

VB C#

In this syntax:

element1 and element2 are variables representing elements from collection1 and collection2.
element1.Key and element2.Key are the properties used as the basis for the join operation.
The equals keyword specifies the condition for the join.
The select clause creates a new object that combines elements from both collections.

Types of LINQ Joins

LINQ supports several types of joins, including:

Inner Join: Returns only the elements that have matching keys in both 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
	}

VB C#

Left Outer Join (Default): Returns all elements from the left collection and the matching elements from the right collection. If no match is found, the result will contain the default value for the right-side elements.

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)
	}

VB C#

Group Join: Group elements from the left collection with matching elements from the right collection.

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
	}

VB C#

Real-world Application: Combining Customer and Order Data

Let's consider a practical example where we have two collections: customers and orders. We want to create a result set that combines customer information with their corresponding orders using the LINQ Join operator.

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
	}

VB C#

In this example, the result set will contain entries with customer information along with their associated orders. The join extension method syntax helps C# developers to perform SQL-like join operations.

Introducing IronPDF

C# LINQ Join Query Syntax (How It Works For Developers): Figure 1 - IronPDF webpage

Develop PDF Solutions with IronPDF is a comprehensive C# library designed for creating, processing, and editing PDF documents. It empowers developers to dynamically generate PDFs from various data sources, making it a versatile solution for applications that require PDF document generation.

Installing IronPDF: A Quick Start

To begin leveraging the IronPDF library in your C# project, you can easily install the IronPDF NuGet package. Use the following command in your Package Manager Console:

Install-Package IronPdf

Alternatively, you can search for "IronPDF" in the NuGet Package Manager and install it from there.

C# LINQ Join Query Syntax (How It Works For Developers): Figure 2 - Installing the IronPDF library from the NuGet package manager

LINQ Join and IronPDF: A Dynamic Duo?

The LINQ Join operator, known for its ability to merge data from disparate sources, can be a valuable asset in scenarios where data integration is key. When it comes to utilizing LINQ Join with IronPDF, the primary consideration is the nature of the data you intend to integrate into the PDF document.

The highlight of IronPDF is its HTML to PDF Conversion function, which keeps your layouts and styles intact. This feature allows for PDF generation from web content, perfect for reports, invoices, and documentation. HTML files, URLs, and HTML strings can be converted to PDFs seamlessly.

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

VB C#

Scenario 1: Combining Data Before PDF Generation

If your goal is to combine data from different data sources before initiating the PDF generation process, LINQ Join can be employed independently. Once you have a unified dataset, you can leverage IronPDF to dynamically generate a PDF document based on the integrated data.

Here's a simplified example:

// Assume 'customerOrderInfo' is a result set obtained using LINQ Join
var pdfDocument = new IronPdf.ChromePdfRenderer();
foreach (var entry in query)
{
    // 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 query)
{
    // 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 query
	' 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")

VB C#

Explore more ways of PDF document generation and how you can use LINQ Join with IronPDF by visiting the IronPDF Documentation.

Scenario 2: Dynamic Data Integration During PDF Generation

IronPDF allows dynamic content addition to PDF documents, making it possible to integrate data using LINQ Join during the PDF generation process itself. Here, we'll create and order the customer class to represent the real-world application. The data sources can be an SQL database or some structured format, in this case, a list of objects containing a set of data attributes, just like tables in the database. The following example shows a detailed integration of the LINQ Join method with IronPDF as we use HTML Strings for PDF Generation to create the 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

VB C#

This code utilizes the join keyword that helps find the matching orders for each customer, making the query more concise and expressive.

C# LINQ Join Query Syntax (How It Works For Developers): Figure 3 - Outputted PDF from the previous code example

Conclusion

In conclusion, IronPDF serves as a robust solution for PDF generation in C# applications. When combined with the powerful LINQ Join operator, developers can achieve seamless data integration before or during the PDF generation process. Whether you need to combine customer information with orders or merge data from diverse sources, the dynamic duo of LINQ Join and IronPDF provides a flexible and efficient approach to enhancing your PDF generation capabilities in C# applications.

In conclusion, the C# LINQ Join operator is a formidable tool for seamlessly integrating data from multiple sources. Whether you're dealing with databases, API responses, or in-memory collections, the LINQ Join operator simplifies the process of combining data based on specified conditions. As you navigate the diverse landscape of data connections in your C# applications, consider the power and flexibility that the LINQ Join operator brings to your data integration toolkit. Mastering this operator opens up new possibilities for efficiently working with and manipulating data, enhancing the capabilities of your C# applications.

IronPDF offers a free trial for evaluation purposes to test out its complete functionality. However, it needs to be properly licensed once the trial period has expired.

< PREVIOUS
C# Sealed Class (How It Works For Developers)

NEXT >
C# String.Format (How It Works For Developers)