AYUDA .NET

Sintaxis de consulta C# LINQ Join (Cómo funciona para desarrolladores)

Actualizado 18 de febrero, 2024
Compartir:

En la versatilidad de la programación en C#, LINQ (Idioma Consulta integrada) destaca como una potente herramienta para consultar y manipular colecciones de objetos. Entre los numerosos operadores que ofrece LINQ, el operador Join es clave a la hora de combinar datos procedentes de múltiples fuentes.

En este artículo, profundizaremos en las complejidades del Operador LINQ Join de C# desentrañando su funcionalidad, sintaxis y aplicaciones en el mundo real.

Conceptos básicos de la cláusula Join

En esencia, el operador LINQ Join está diseñado para combinar elementos de dos o más colecciones basándose en una condición especificada. Este operador permite a los desarrolladores realizar uniones de tipo SQL en colecciones en memoria, facilitando la fusión de datos de fuentes dispares con facilidad.

Sintaxis del operador LINQ Join

La sintaxis del operador LINQ Join es expresiva y sigue un patrón que se asemeja a las uniones SQL. La sintaxis básica es la siguiente:

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#

En esta sintaxis:

  • elemento1 y elemento2 son variables que representan elementos de colección1 y colección2.
  • elemento1.Clave y elemento2.Clave son las propiedades utilizadas como base para la operación join.
  • La palabra clave equals especifica la condición para la unión.
  • La cláusula select crea un nuevo objeto que combina elementos de ambas colecciones.

Tipos de uniones LINQ

LINQ admite varios tipos de uniones, entre los que se incluyen:

  1. Unión interna: Devuelve sólo los elementos que tienen claves coincidentes en ambas colecciones.
var innerJoin = from customer in customers
                    join order in orders on customer.CustomerID equals order.CustomerID //  unir pedidos a clientes basándose en la clave de identificación del cliente
                    select new { customer.CustomerID, customer.CustomerName, order.OrderID }; //  crear un nuevo objeto anónimo basado en los objetos obtenidos de la unión
var innerJoin = from customer in customers
                    join order in orders on customer.CustomerID equals order.CustomerID //  unir pedidos a clientes basándose en la clave de identificación del cliente
                    select new { customer.CustomerID, customer.CustomerName, order.OrderID }; //  crear un nuevo objeto anónimo basado en los objetos obtenidos de la unión
Dim innerJoin = From customer In customers '  crear un nuevo objeto anónimo basado en los objetos obtenidos de la unión
	Join order In orders On customer.CustomerID Equals order.CustomerID
	Select New With {
		Key customer.CustomerID,
		Key customer.CustomerName,
		Key order.OrderID
	}
VB   C#
  1. Unión exterior izquierda (Por defecto): Devuelve todos los elementos de la colección izquierda y los elementos coincidentes de la colección derecha. Si no se encuentra ninguna coincidencia, el resultado contendrá el valor por defecto para los elementos del lado derecho.
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#
  1. Agrupar elementos: Agrupar elementos de la colección izquierda con elementos coincidentes de la colección derecha.
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#

Aplicación real: Combinación de datos de clientes y pedidos

Veamos un ejemplo práctico en el que tenemos dos colecciones: clientes y pedidos. Queremos crear un conjunto de resultados que combine la información de los clientes con sus pedidos correspondientes utilizando el operador LINQ Join.

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#

En este ejemplo, el conjunto de resultados contendrá entradas con información de clientes junto con sus pedidos asociados. La sintaxis del método de extensión join ayuda a los desarrolladores de C# a realizar operaciones join similares a las de SQL.

Presentación de IronPDF

Sintaxis de consulta C# LINQ Join (Cómo funciona para desarrolladores): Figura 1 - Página web de IronPDF

IronPDF es una completa biblioteca de C# diseñada para crear, procesar y editar documentos PDF. Permite a los desarrolladores generar PDF dinámicamente a partir de diversas fuentes de datos, lo que la convierte en una solución versátil para aplicaciones que requieren la generación de documentos PDF.

Instalación de IronPDF: Inicio rápido

Para empezar a aprovechar la biblioteca IronPDF en su proyecto C#, puede instalar fácilmente el paquete IronPDF NuGet. Utilice el siguiente comando en la consola del gestor de paquetes:

Install-Package IronPdf

También puede buscar "IronPDF" en el gestor de paquetes NuGet e instalarlo desde allí.

Sintaxis de consulta C# LINQ Join (Cómo funciona para desarrolladores): Figura 2 - Instalación de la biblioteca IronPDF desde el gestor de paquetes NuGet

LINQ Join e IronPDF: ¿Un dúo dinámico?

El operador LINQ Join, conocido por su capacidad para fusionar datos procedentes de fuentes dispares, puede ser un activo valioso en escenarios en los que la integración de datos es clave. Cuando se trata de utilizar LINQ Join con IronPDF, la consideración principal es la naturaleza de los datos que pretende integrar en el documento PDF.

Escenario 1: Combinación de datos antes de la generación del PDF

Si su objetivo es combinar datos de diferentes fuentes de datos antes de iniciar el proceso de generación de PDF, LINQ Join puede emplearse de forma independiente. Una vez que tenga un conjunto de datos unificado, puede aprovechar IronPDF para generar dinámicamente un documento PDF basado en los datos integrados.

He aquí un ejemplo simplificado:

//  Supongamos que 'customerOrderInfo' es un conjunto de resultados obtenido mediante LINQ Join
var pdfDocument = new IronPdf.ChromePdfRenderer();
foreach (var entry in query)
{
    //  Utilice IronPDF para añadir contenido al PDF basado en datos integrados
    pdfDocument.AddHTML($"<p>Customer ID: {entry.CustomerID}, Order ID: {entry.OrderID}</p>");
}
//  Guarde o reproduzca el documento PDF según sea necesario
pdfDocument.SaveAs("IntegratedDataDocument.pdf");
//  Supongamos que 'customerOrderInfo' es un conjunto de resultados obtenido mediante LINQ Join
var pdfDocument = new IronPdf.ChromePdfRenderer();
foreach (var entry in query)
{
    //  Utilice IronPDF para añadir contenido al PDF basado en datos integrados
    pdfDocument.AddHTML($"<p>Customer ID: {entry.CustomerID}, Order ID: {entry.OrderID}</p>");
}
//  Guarde o reproduzca el documento PDF según sea necesario
pdfDocument.SaveAs("IntegratedDataDocument.pdf");
'  Supongamos que 'customerOrderInfo' es un conjunto de resultados obtenido mediante LINQ Join
Dim pdfDocument = New IronPdf.ChromePdfRenderer()
For Each entry In query
	'  Utilice IronPDF para añadir contenido al PDF basado en datos integrados
	pdfDocument.AddHTML($"<p>Customer ID: {entry.CustomerID}, Order ID: {entry.OrderID}</p>")
Next entry
'  Guarde o reproduzca el documento PDF según sea necesario
pdfDocument.SaveAs("IntegratedDataDocument.pdf")
VB   C#

Explore más formas de generación de documentos PDF y cómo puede utilizar LINQ Join con IronPDF visitando la página documentación página.

Escenario 2: Integración dinámica de datos durante la generación de PDF

IronPDF permite añadir contenido dinámico a los documentos PDF, haciendo posible la integración de datos mediante LINQ Join durante el propio proceso de generación del PDF. Aquí, crearemos y ordenaremos la clase cliente para representar la aplicación del mundo real. Las fuentes de datos pueden ser una base de datos SQL o algún formato estructurado, en este caso, una lista de objetos que contienen un conjunto de atributos de datos, al igual que las tablas de la base de datos. El siguiente ejemplo muestra una integración detallada del método LINQ Join con IronPDF, ya que utilizamos Cadenas HTML para generar el documento:

using System;
using System.Collections.Generic;
using System.Linq;
using IronPdf;
class Order
{
    public int OrderID { get; set; }
    public int CustomerID { get; set; }
    //  Otras propiedades relacionadas con el orden...
}
class Customer
{
    public int CustomerID { get; set; }
    //  Otras propiedades relacionadas con el cliente...
}
class Program
{
    static void Main()
    {
        //  Recogida de pedidos de muestras
        var orders = new List<Order>
        {
            new Order { OrderID = 1, CustomerID = 1 },
            new Order { OrderID = 2, CustomerID = 1 },
            new Order { OrderID = 3, CustomerID = 2 },
        };
        //  Recogida de muestras de clientes
        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>";
    //  Utilizar join para buscar pedidos de clientes
    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)
    {
            //  Utilice IronPDF para añadir dinámicamente contenido al PDF basado en datos integrados
            htmlContent += $"<p>Customer ID: {result.CustomerID}, Order ID: {result.OrderID}</p>";
    }
    //  Guarde o reproduzca el documento PDF según sea necesario
    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; }
    //  Otras propiedades relacionadas con el orden...
}
class Customer
{
    public int CustomerID { get; set; }
    //  Otras propiedades relacionadas con el cliente...
}
class Program
{
    static void Main()
    {
        //  Recogida de pedidos de muestras
        var orders = new List<Order>
        {
            new Order { OrderID = 1, CustomerID = 1 },
            new Order { OrderID = 2, CustomerID = 1 },
            new Order { OrderID = 3, CustomerID = 2 },
        };
        //  Recogida de muestras de clientes
        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>";
    //  Utilizar join para buscar pedidos de clientes
    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)
    {
            //  Utilice IronPDF para añadir dinámicamente contenido al PDF basado en datos integrados
            htmlContent += $"<p>Customer ID: {result.CustomerID}, Order ID: {result.OrderID}</p>";
    }
    //  Guarde o reproduzca el documento PDF según sea necesario
    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
	'  Otras propiedades relacionadas con el orden...
End Class
Friend Class Customer
	Public Property CustomerID() As Integer
	'  Otras propiedades relacionadas con el cliente...
End Class
Friend Class Program
	Shared Sub Main()
		'  Recogida de pedidos de muestras
		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
			}
		}
		'  Recogida de muestras de clientes
		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>"
	'  Utilizar join para buscar pedidos de clientes
	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
			'  Utilice IronPDF para añadir dinámicamente contenido al PDF basado en datos integrados
			htmlContent &= $"<p>Customer ID: {result.CustomerID}, Order ID: {result.OrderID}</p>"
	Next result
	'  Guarde o reproduzca el documento PDF según sea necesario
	pdfDocument.RenderHtmlAsPdf(htmlContent).SaveAs("DynamicIntegratedDataDocument.pdf")
	End Sub
End Class
VB   C#

Este código utiliza la palabra clave join que ayuda a encontrar los pedidos coincidentes para cada cliente, haciendo la consulta más concisa y expresiva.

Sintaxis de consulta C# LINQ Join (Cómo funciona para desarrolladores): Figura 3 - PDF resultante del ejemplo de código anterior

Conclusión

En conclusión, IronPDF es una solución robusta para la generación de PDF en aplicaciones C#. Cuando se combina con el potente operador LINQ Join, los desarrolladores pueden lograr una integración de datos perfecta antes o durante el proceso de generación de PDF. Tanto si necesita combinar información de clientes con pedidos o fusionar datos de diversas fuentes, el dúo dinámico de LINQ Join e IronPDF proporciona un enfoque flexible y eficaz para mejorar sus capacidades de generación de PDF en aplicaciones C#.

En conclusión, el operador LINQ Join de C# es una herramienta formidable para integrar a la perfección datos procedentes de múltiples fuentes. Tanto si trabaja con bases de datos, respuestas de API o colecciones en memoria, el operador LINQ Join simplifica el proceso de combinación de datos en función de condiciones especificadas. Mientras navega por el variado panorama de las conexiones de datos en sus aplicaciones C#, tenga en cuenta la potencia y flexibilidad que el operador LINQ Join aporta a su conjunto de herramientas de integración de datos. El dominio de este operador abre nuevas posibilidades para trabajar y manipular datos con eficacia, mejorando las capacidades de sus aplicaciones C#.

IronPDF ofrece un **Prueba gratuita para probar todas sus funciones. Sin embargo, es necesario licencia una vez finalizado el periodo de prueba.

< ANTERIOR
C# Sealed Class (Cómo funciona para los desarrolladores)
SIGUIENTE >
C# String.Format (Cómo funciona para desarrolladores)

¿Listo para empezar? Versión: 2024.6 recién publicada

Comenzar prueba gratuita Descargas totales: 9,661,997
Ver licencias >