Cuando se trabaja con aplicaciones multihilo en C#, mantener la integridad de los datos es crucial, especialmente cuando se generan documentos PDF sobre la marcha utilizando una biblioteca como IronPDF. La clase ConcurrentDictionary<tkey, tvalue> proporciona una colección segura para hilos que gestiona pares de claves y valores de manera eficiente, incluso cuando múltiples hilos realizan operaciones como inserciones, actualizaciones o búsquedas concurrentemente.
En esta guía, exploraremos cómo funciona ConcurrentDictionary, cómo se puede integrar con IronPDF para procesamiento paralelo de PDF y lo que todo desarrollador de .NET necesita saber sobre el tipo de clave, la seguridad de los hilos y las trampas comunes como manejar una clave existente o asegurar la consistencia de los datos.
La clase ConcurrentDictionary<tkey, tvalue>, parte del espacio de nombres System.Collections.Concurrent, es una colección genérica diseñada para operaciones de alto rendimiento y seguras para hilos. A diferencia de un diccionario regular, permite que múltiples hilos accedan y modifiquen la colección de forma segura sin bloquear toda la estructura.
Una nueva instancia de ConcurrentDictionary<string, string> podría lucir así:
var dictionary = new ConcurrentDictionary<string, string>();Dim dictionary = New ConcurrentDictionary(Of String, String)()Puedes definir tus propios tipos TKey y TValue en función de tu caso de uso específico, como el almacenamiento en caché de rutas de archivos PDF renderizados o el rastreo de tareas de generación concurrentes de PDF.
Imagina que estás construyendo un programa que genera facturas personalizadas usando IronPDF para miles de usuarios. Si cada hilo necesita renderizar un documento y almacenar su resultado, un diccionario regular introduciría condiciones de carrera o lanzaría excepciones si ya existe una clave.
El uso de ConcurrentDictionary asegura:
Desglosemos los métodos clave usando escenarios de renderización de IronPDF.
Este método verifica si existe una clave específica. Si no existe, añade el nuevo valor.
var filePath = pdfCache.GetOrAdd(userId, id => GeneratePdfForUser(id));Dim filePath = pdfCache.GetOrAdd(userId, Function(id) GeneratePdfForUser(id))Este método te permite actualizar el valor si la clave existe, o añadir un nuevo par clave-valor.
pdfCache.AddOrUpdate(userId,
id => GeneratePdfForUser(id),
(id, existingValue) => UpdatePdfForUser(id, existingValue));pdfCache.AddOrUpdate(userId, Function(id) GeneratePdfForUser(id), Function(id, existingValue) UpdatePdfForUser(id, existingValue))Este método intenta agregar un valor y devuelve un valor booleano que indica éxito.
bool added = pdfCache.TryAdd(userId, pdfBytes);
if (!added)
{
Console.WriteLine("PDF already cached.");
}Dim added As Boolean = pdfCache.TryAdd(userId, pdfBytes)
If Not added Then
Console.WriteLine("PDF already cached.")
End If
ConcurrentDictionary admite ajustes a través del constructor:
int concurrencyLevel = 4;
int initialCapacity = 100;
var dictionary = new ConcurrentDictionary<string, byte[]>(concurrencyLevel, initialCapacity);Dim concurrencyLevel As Integer = 4
Dim initialCapacity As Integer = 100
Dim dictionary = New ConcurrentDictionary(Of String, Byte())(concurrencyLevel, initialCapacity)Configurar adecuadamente estos parámetros mejora el rendimiento global y reduce las contenciones entre múltiples hilos.
Cuando una clave no existe, operaciones como TryGetValue pueden devolver el valor por defecto del tipo:
if (!pdfCache.TryGetValue(userId, out var pdf))
{
pdf = GeneratePdfForUser(userId); // Second call
}Dim pdf As var
If Not pdfCache.TryGetValue(userId, pdf) Then
pdf = GeneratePdfForUser(userId) ' Second call
End IfEsto protege tu código contra referencias desconocidas o nulas. Siempre verifica un valor específico antes de asumir su presencia.
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using IronPdf;
public class Program
{
static ConcurrentDictionary<string, byte[]> pdfReports =
new ConcurrentDictionary<string, byte[]>();
static void Main(string[] args)
{
// Simulated user list with HTML content
var users = new List<User>
{
new User { Id = "user1", HtmlContent = "<h1>Report for User 1</h1>" },
new User { Id = "user2", HtmlContent = "<h1>Report for User 2</h1>" },
new User { Id = "user3", HtmlContent = "<h1>Report for User 3</h1>" }
};
// Generate PDFs concurrently
var renderer = new ChromePdfRenderer();
Parallel.ForEach(users, user =>
{
var pdf = pdfReports.GetOrAdd(user.Id, id =>
{
var pdfDoc = renderer.RenderHtmlAsPdf(user.HtmlContent);
return pdfDoc.BinaryData;
});
SaveToFile(pdf, $"{user.Id}.pdf");
});
Console.WriteLine("PDF generation complete.");
}
// Utility method to write PDF binary data to file
static void SaveToFile(byte[] pdfBytes, string filePath)
{
File.WriteAllBytes(filePath, pdfBytes);
Console.WriteLine($"Saved: {filePath}");
}
}
// Simple user class with ID and HTML content
public class User
{
public string Id { get; set; }
public string HtmlContent { get; set; }
}Imports System
Imports System.Collections.Concurrent
Imports System.Collections.Generic
Imports System.IO
Imports System.Threading.Tasks
Imports IronPdf
Public Class Program
Private Shared pdfReports As New ConcurrentDictionary(Of String, Byte())()
Shared Sub Main(ByVal args() As String)
' Simulated user list with HTML content
Dim users = New List(Of User) From {
New User With {
.Id = "user1",
.HtmlContent = "<h1>Report for User 1</h1>"
},
New User With {
.Id = "user2",
.HtmlContent = "<h1>Report for User 2</h1>"
},
New User With {
.Id = "user3",
.HtmlContent = "<h1>Report for User 3</h1>"
}
}
' Generate PDFs concurrently
Dim renderer = New ChromePdfRenderer()
Parallel.ForEach(users, Sub(user)
Dim pdf = pdfReports.GetOrAdd(user.Id, Function(id)
Dim pdfDoc = renderer.RenderHtmlAsPdf(user.HtmlContent)
Return pdfDoc.BinaryData
End Function)
SaveToFile(pdf, $"{user.Id}.pdf")
End Sub)
Console.WriteLine("PDF generation complete.")
End Sub
' Utility method to write PDF binary data to file
Private Shared Sub SaveToFile(ByVal pdfBytes() As Byte, ByVal filePath As String)
File.WriteAllBytes(filePath, pdfBytes)
Console.WriteLine($"Saved: {filePath}")
End Sub
End Class
' Simple user class with ID and HTML content
Public Class User
Public Property Id() As String
Public Property HtmlContent() As String
End Class
Este ejemplo demuestra cómo combinar ConcurrentDictionary<TKey, TValue> con IronPDF para generar PDFs de manera segura para hilos. Es perfecto para aplicaciones donde múltiples hilos están procesando y almacenando en caché archivos PDF simultáneamente.
¿Por qué ConcurrentDictionary?
Asegura un acceso seguro para hilos a pares clave-valor.
GetOrAdd() evita la generación duplicada de PDFs.
No se necesitan bloqueos manuales, perfecto para alta concurrencia. Cómo Funciona
Una lista de usuarios, cada uno tiene un ID y HTML.
Parallel.ForEach lanza hilos para generar PDFs.
Cada hilo usa GetOrAdd() para obtener o crear el PDF.
El PDF se guarda usando el ID del usuario como nombre de archivo. Resumen
Este patrón es ideal cuando:
Aunque ConcurrentDictionary no expone todas las características de LINQ, aún puedes usar métodos de extensión para consultar valores:
var completedKeys = pdfReports.Keys.Where(k => k.StartsWith("done-")).ToList();Dim completedKeys = pdfReports.Keys.Where(Function(k) k.StartsWith("done-")).ToList()Sin embargo, evita confiar en elementos copiados durante la iteración ya que el diccionario puede cambiar. Utiliza .ToList() o .ToArray() para trabajar con una instantánea si es necesario.
La ConcurrentDictionary<TKey, TValue> es ideal para escenarios donde varios threads necesitan leer/escribir pares clave-valor simultáneamente, haciéndola un compañero perfecto para IronPDF en aplicaciones multihilo.
Ya sea que estés almacenando en caché PDFs renderizados, rastreando el estado de trabajos o previniendo operaciones redundantes, usar esta colección segura para threads asegura que tu lógica escale con rendimiento y fiabilidad.
¿Listo para construir aplicaciones PDF de alto rendimiento con total seguridad en los hilos? Descarga una prueba gratuita de IronPDF y experimenta una generación PDF fluida combinada con el poder de la ConcurrentDictionary de C#.
Jacob Mellor es Director de Tecnología de Iron Software y un ingeniero visionario pionero en la tecnología C# PDF. Como desarrollador original de la base de código principal de Iron Software, ha dado forma a la arquitectura de productos de la empresa desde su creación, transformándola, junto con el director ejecutivo Cameron Rimington, en una empresa de más de 50 personas que presta servicios a la NASA, Tesla y organismos gubernamentales de todo el mundo.
IronPDF es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
Cuando necesitas que tu PDF se parezca al HTML, rápido.
