Lista concurrente en C# (Cómo funciona para desarrolladores)

Seguridad de hilos y colecciones concurrentes en C#;

Comencemos imaginando una intersección de una ciudad bulliciosa sin semáforos. ¡Puedes imaginar el caos! Esto es similar a lo que sucede cuando varios hilos acceden de manera concurrente a un recurso compartido sin un sistema adecuado en su lugar. Afortunadamente, en C#, tenemos semáforos para nuestros hilos: estos se llaman colecciones concurrentes. Son clases de colección que permiten que sólo un hilo acceda a un recurso a la vez. Esta seguridad de hilos es crucial al trabajar con múltiples hilos.

Explorando las colecciones concurrentes a prueba de hilos en C#;

En C#, el espacio de nombres System.Collections.Concurrent tiene una variedad de clases de colección concurrente, como ConcurrentDictionary, ConcurrentQueue, ConcurrentStack, y ConcurrentBag. Estas clases de colección desordenadas proporcionan una versión a prueba de hilos de sus contrapartes no concurrentes. Lo que diferencia a las colecciones concurrentes es que son colecciones concurrentes desordenadas, lo que significa que los elementos no tienen un orden específico. Por ejemplo, con una lista concurrente, no sabes exactamente dónde se inserta un elemento. El enfoque está en asegurar la seguridad de los hilos, no en mantener un orden.

Tomemos un ejemplo de la vida real. Piensa en una publicación de envío de contraseñas en un sitio web. Con una colección concurrente, múltiples usuarios pueden enviar sus contraseñas simultáneamente. Cada acción de 'enviar' es como un hilo, y la colección concurrente asegura que cada envío sea seguro para los hilos, procesado de forma segura y efectiva.

ConcurrentDictionary: Un ejemplo del mundo real

Ahora, exploremos la clase de colección ConcurrentDictionary con un ejemplo de la vida real. Imagina una librería en línea con una función de recomendaciones. Cada clic de un usuario agrega un libro a su lista personal de recomendaciones, representada por un diccionario. A medida que múltiples usuarios navegan y hacen clic en libros al mismo tiempo, tenemos múltiples hilos accediendo al diccionario de manera concurrente.

Un ConcurrentDictionary en C# se vería algo así:

using System.Collections.Concurrent;

ConcurrentDictionary<string, string> recommendedBooks = new ConcurrentDictionary<string, string>();

using System.Collections.Concurrent;

ConcurrentDictionary<string, string> recommendedBooks = new ConcurrentDictionary<string, string>();

Para agregar un libro a la colección completa de recomendaciones de un usuario, podríamos usar el método TryAdd:

public void Insert(string user, string book)
{
    // Try to add the book to the user's recommendations
    recommendedBooks.TryAdd(user, book);
}

public void Insert(string user, string book)
{
    // Try to add the book to the user's recommendations
    recommendedBooks.TryAdd(user, book);
}

En este escenario, la clase de colección ConcurrentDictionary asegura que cada clic (o 'hilo') se trate de manera individual, de modo que las recomendaciones de ningún usuario se mezclen. Se encarga de toda la seguridad de los hilos, para que no tengas que preocuparte por carreras de datos y otros problemas de concurrencia relacionados con múltiples hilos.

Implementación de operaciones seguras de subprocesos

Aparte de TryAdd, las colecciones concurrentes en C# proporcionan una variedad de otras operaciones seguras para hilos, como TryRemove y TryUpdate. Estos métodos aseguran que solo un hilo pueda realizar una operación a la vez. Así que, por ejemplo, si quisiéramos eliminar un libro de las recomendaciones de un usuario en el ejemplo anterior, podríamos usar el método TryRemove:

public void RemoveAt(string user)
{
    // Attempt to remove the book for the specified user
    string removedBook;
    recommendedBooks.TryRemove(user, out removedBook);
}

public void RemoveAt(string user)
{
    // Attempt to remove the book for the specified user
    string removedBook;
    recommendedBooks.TryRemove(user, out removedBook);
}

El método TryRemove intentará eliminar el valor de la clave proporcionada (en este caso, un usuario) y colocarlo en la variable removedBook.

Copiado de colecciones concurrentes

Ahora, digamos que quieres copiar tu colección concurrente a un arreglo. Las colecciones concurrentes proporcionan un método CopyTo para este propósito exacto:

public void CopyTo()
{
    // Create an array to hold the recommended books
    string[] bookArray = new string[recommendedBooks.Count];

    // Copy the values of the concurrent dictionary to the array
    recommendedBooks.Values.CopyTo(bookArray, 0);
}

public void CopyTo()
{
    // Create an array to hold the recommended books
    string[] bookArray = new string[recommendedBooks.Count];

    // Copy the values of the concurrent dictionary to the array
    recommendedBooks.Values.CopyTo(bookArray, 0);
}

Aquí, el método CopyTo copia todos los libros (valores) del diccionario concurrente recommendedBooks en el bookArray.

Recogida segura de hilos

C# también proporciona colecciones seguras para hilos, que están diseñadas para asegurar un acceso seguro a recursos compartidos en entornos multihilo. Estas colecciones, como ConcurrentBag, ConcurrentQueue, y ConcurrentStack, ofrecen implementaciones seguras para hilos donde múltiples hilos pueden acceder y modificar la colección de manera concurrente sin causar conflictos o corrupción de datos.

Garantizan consistencia e integridad manejando la sincronización internamente, haciéndolas ideales para escenarios donde una colección desordenada es suficiente, y la seguridad de hilos es de suma importancia en tus aplicaciones C#.

Aprende Más Sobre IronPDF es una popular biblioteca de C# que te permite generar documentos PDF a partir de HTML sin esfuerzo.

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

Aunque al principio puede no parecer directamente relacionado con las listas concurrentes, IronPDF puede complementar tus operaciones de colección concurrente proporcionando una manera fácil de crear informes en PDF, registros, o cualquier otro documento que capture los resultados de tu procesamiento concurrente.

Considera el escenario donde tienes una aplicación multihilo que realiza un procesamiento de datos intensivo. A medida que los hilos trabajan su magia en los datos, podrías querer capturar los resultados y generar un informe en PDF para un análisis más profundo o para llevar un registro. Aquí es donde entra en juego IronPDF.

Usar IronPDF es tan simple como agregar la biblioteca a tu proyecto y utilizar su cómodo API. Aquí tienes un ejemplo de cómo puedes integrar IronPDF con tus operaciones de colección concurriente:

using IronPdf;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading.Tasks;

// Create a concurrent dictionary to hold your processed data
ConcurrentDictionary<int, string> processedData = new ConcurrentDictionary<int, string>();

// Define your data list (replace with your actual data source)
List<DataItem> dataList = GetDataList();

// Process your data concurrently and store the results in the dictionary
Parallel.ForEach(dataList, (dataItem) =>
{
    // Process each data item and add the result to the dictionary
    string processedResult = ProcessDataItem(dataItem);
    processedData.TryAdd(dataItem.Id, processedResult);
});

// Generate a PDF report with the processed data
var renderer = new ChromePdfRenderer();
var pdfDocument = renderer.RenderHtmlAsPdf(BuildHtmlReport(processedData));
pdfDocument.SaveAs("C:\\processed_data_report.pdf");

// Method to retrieve the data list (replace with your actual data source logic)
List<DataItem> GetDataList()
{
    List<DataItem> dataList = new List<DataItem>()
    {
        new DataItem { Id = 1, Name = "Item 1" },
        new DataItem { Id = 2, Name = "Item 2" },
        new DataItem { Id = 3, Name = "Item 3" },
        new DataItem { Id = 4, Name = "Item 4" }
    };
    return dataList;
}

// Method to process each data item and return the result (replace with your actual data processing logic)
string ProcessDataItem(DataItem dataItem)
{
    // Simulating data processing with a delay
    Task.Delay(100).Wait();
    return $"Processed: {dataItem.Name}";
}

// Method to build the HTML report using the processed data (replace with your actual reporting logic)
string BuildHtmlReport(ConcurrentDictionary<int, string> processedData)
{
    string html = "<h1>Processed Data Report</h1><ul>";
    foreach (var kvp in processedData)
    {
        html += $"<li>Item {kvp.Key}: {kvp.Value}</li>";
    }
    html += "</ul>";
    return html;
}

// Placeholder class for your data item (replace with your actual data item class)
public class DataItem
{
    public int Id { get; set; }
    public string Name { get; set; }
    // Add other properties as needed
}

using IronPdf;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading.Tasks;

// Create a concurrent dictionary to hold your processed data
ConcurrentDictionary<int, string> processedData = new ConcurrentDictionary<int, string>();

// Define your data list (replace with your actual data source)
List<DataItem> dataList = GetDataList();

// Process your data concurrently and store the results in the dictionary
Parallel.ForEach(dataList, (dataItem) =>
{
    // Process each data item and add the result to the dictionary
    string processedResult = ProcessDataItem(dataItem);
    processedData.TryAdd(dataItem.Id, processedResult);
});

// Generate a PDF report with the processed data
var renderer = new ChromePdfRenderer();
var pdfDocument = renderer.RenderHtmlAsPdf(BuildHtmlReport(processedData));
pdfDocument.SaveAs("C:\\processed_data_report.pdf");

// Method to retrieve the data list (replace with your actual data source logic)
List<DataItem> GetDataList()
{
    List<DataItem> dataList = new List<DataItem>()
    {
        new DataItem { Id = 1, Name = "Item 1" },
        new DataItem { Id = 2, Name = "Item 2" },
        new DataItem { Id = 3, Name = "Item 3" },
        new DataItem { Id = 4, Name = "Item 4" }
    };
    return dataList;
}

// Method to process each data item and return the result (replace with your actual data processing logic)
string ProcessDataItem(DataItem dataItem)
{
    // Simulating data processing with a delay
    Task.Delay(100).Wait();
    return $"Processed: {dataItem.Name}";
}

// Method to build the HTML report using the processed data (replace with your actual reporting logic)
string BuildHtmlReport(ConcurrentDictionary<int, string> processedData)
{
    string html = "<h1>Processed Data Report</h1><ul>";
    foreach (var kvp in processedData)
    {
        html += $"<li>Item {kvp.Key}: {kvp.Value}</li>";
    }
    html += "</ul>";
    return html;
}

// Placeholder class for your data item (replace with your actual data item class)
public class DataItem
{
    public int Id { get; set; }
    public string Name { get; set; }
    // Add other properties as needed
}

Aquí está la salida del código:

Conclusión

En conclusión, entender y utilizar colecciones concurrentes de C#, como listas concurrentes, puede mejorar enormemente tu habilidad para manejar escenarios multihilo y asegurar la seguridad de hilos en tus aplicaciones. Con colecciones concurrentes, puedes gestionar recursos compartidos de manera efectiva, previniendo carreras de datos y colisiones entre hilos.

Integrar bibliotecas externas como IronPDF puede aumentar aún más la funcionalidad de colecciones concurrentes permitiendo la generación de informes PDF visualmente atractivos o documentos. IronPDF ofrece una prueba gratuita de su biblioteca para la conversión de HTML a PDF, permitiéndote explorar sus capacidades, y opciones de licencia a partir de $799.