Se você já teve várias threads disputando o acesso a um recurso compartilhado, sabe que a implementação thread-safe não é brincadeira. Mas não se preocupe! O C# oferece soluções com coleções concorrentes — um conjunto poderoso de classes de coleção genéricas e thread-safe que garantem segurança de threads com estilo e elegância.
Vamos começar imaginando um cruzamento movimentado em uma cidade, sem semáforos. Dá para imaginar o caos! Isso é semelhante ao que acontece quando várias threads acessam simultaneamente um recurso compartilhado sem um sistema adequado em vigor. Felizmente, em C#, temos semáforos para nossas threads — são chamadas de coleções concorrentes. São classes de coleção que permitem que apenas uma thread acesse um recurso por vez. Essa segurança de threads é crucial ao trabalhar com múltiplas threads.
Em C#, o namespace System.Collections.Concurrent possui uma variedade de classes de coleção simultâneas, como ConcurrentDictionary, ConcurrentQueue, ConcurrentStack, e ConcurrentBag. Essas classes de coleções não ordenadas fornecem uma versão thread-safe de suas contrapartes não concorrentes. O que diferencia as coleções concorrentes é que elas são coleções concorrentes não ordenadas, ou seja, os elementos não possuem uma ordem específica. Por exemplo, em uma lista concorrente, você não sabe exatamente onde um item será inserido. O foco está em garantir a segurança de threads, não em manter a ordem.
Vejamos um exemplo da vida real. Imagine um campo para envio de senhas em um site. Com uma coleta simultânea, vários usuários podem enviar suas senhas ao mesmo tempo. Cada ação de 'enviar' é como uma thread, e a coleção concorrente garante que cada envio seja seguro para threads, processado de forma segura e eficaz.
Agora, vamos explorar a classe de coleção ConcurrentDictionary com um exemplo real. Imagine uma livraria online com um recurso de recomendação. Cada clique do usuário adiciona um livro à sua lista pessoal de recomendações, representada por um dicionário. Como vários usuários navegam e clicam em livros ao mesmo tempo, temos várias threads acessando o dicionário simultaneamente.
Um ConcurrentDictionary em C# se pareceria com isto:
using System.Collections.Concurrent;
ConcurrentDictionary<string, string> recommendedBooks = new ConcurrentDictionary<string, string>();Imports System.Collections.Concurrent
Private recommendedBooks As New ConcurrentDictionary(Of String, String)()Para adicionar um livro à coleção inteira de recomendações de um usuário, podemos usar o 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 Sub Insert(ByVal user As String, ByVal book As String)
' Try to add the book to the user's recommendations
recommendedBooks.TryAdd(user, book)
End SubNeste cenário, a classe de coleção ConcurrentDictionary garante que cada clique (ou 'thread') seja tratado individualmente, para que as recomendações de dois usuários não se misturem. Ele cuida de toda a segurança dos threads, então você não precisa se preocupar com disputas de dados e outros problemas de simultaneidade relacionados a múltiplos threads.
Além de TryAdd, coleções simultâneas em C# fornecem uma variedade de outras operações seguras para threads como TryRemove e TryUpdate. Esses métodos garantem que apenas um thread pode executar uma operação por vez. Então, por exemplo, se quisermos remover um livro das recomendações de um usuário no exemplo anterior, podemos usar o 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 Sub RemoveAt(ByVal user As String)
' Attempt to remove the book for the specified user
Dim removedBook As String = Nothing
recommendedBooks.TryRemove(user, removedBook)
End SubO método TryRemove tentará remover o valor da chave fornecida (nesse caso, um usuário) e colocá-lo na variável removedBook.
Agora, digamos que você queira copiar sua coleção concorrente para uma matriz. Coleções simultâneas oferecem um método CopyTo para esse propósito específico:
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 Sub CopyTo()
' Create an array to hold the recommended books
Dim bookArray As String() = New String(recommendedBooks.Count - 1) {}
' Copy the values of the concurrent dictionary to the array
recommendedBooks.Values.CopyTo(bookArray, 0)
End SubAqui, o método CopyTo copia todos os livros (valores) do dicionário simultâneo recommendedBooks para o bookArray.
O C# também fornece coleções thread-safe , que são projetadas para garantir o acesso seguro a recursos compartilhados em ambientes multithread. Essas coleções, como ConcurrentBag, ConcurrentQueue e ConcurrentStack, oferecem implementações seguras para threads onde múltiplos threads podem acessar e modificar a coleção simultaneamente sem causar conflitos ou corrupção de dados.
Eles garantem consistência e integridade ao lidar com a sincronização internamente, tornando-os ideais para cenários onde uma coleção não ordenada é suficiente e a segurança de threads é de extrema importância em seus aplicativos C#.
Saiba mais sobre o IronPDF , uma biblioteca popular em C# que permite gerar documentos PDF a partir de HTML sem esforço .
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 ClassEmbora à primeira vista possa não parecer diretamente relacionado a listas concorrentes, o IronPDF pode complementar suas operações de coleta concorrente, fornecendo uma maneira fácil de criar relatórios em PDF, registros ou qualquer outro documento que capture os resultados do seu processamento concorrente.
Considere o cenário em que você tem um aplicativo multithread que realiza processamento intensivo de dados. À medida que os threads processam os dados, você pode querer capturar os resultados e gerar um relatório em PDF para análises posteriores ou para fins de registro. É aí que o IronPDF entra em ação.
Usar o IronPDF é tão simples quanto adicionar a biblioteca ao seu projeto e utilizar sua API prática. Aqui está um exemplo de como você pode integrar o IronPDF às suas operações de coleta simultânea:
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
}Imports IronPdf
Imports System.Collections.Concurrent
Imports System.Collections.Generic
Imports System.Threading.Tasks
' Create a concurrent dictionary to hold your processed data
Private processedData As New ConcurrentDictionary(Of Integer, String)()
' Define your data list (replace with your actual data source)
Private dataList As List(Of DataItem) = GetDataList()
' Process your data concurrently and store the results in the dictionary
Parallel.ForEach(dataList, Sub(dataItem)
' Process each data item and add the result to the dictionary
Dim processedResult As String = ProcessDataItem(dataItem)
processedData.TryAdd(dataItem.Id, processedResult)
End Sub)
' Generate a PDF report with the processed data
Dim renderer = New ChromePdfRenderer()
Dim 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)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'List(Of 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)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'string ProcessDataItem(DataItem dataItem)
'{
' ' Simulating data processing with a delay
' Task.Delay(100).Wait();
' Return string.Format("Processed: {0}", dataItem.Name);
'}
' Method to build the HTML report using the processed data (replace with your actual reporting logic)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'string BuildHtmlReport(ConcurrentDictionary(Of int, string) processedData)
'{
' string html = "<h1>Processed Data Report</h1><ul>";
' foreach (var kvp in processedData)
' {
' html += string.Format("<li>Item {0}: {1}</li>", kvp.Key, kvp.Value);
' }
' html += "</ul>";
' Return html;
'}
' Placeholder class for your data item (replace with your actual data item class)
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'public class DataItem
'{
' public int Id
' {
' get;
' set;
' }
' public string Name
' {
' get;
' set;
' }
' ' Add other properties as needed
'}Aqui está o resultado do código:
Em resumo, compreender e utilizar coleções concorrentes em C#, como listas concorrentes, pode melhorar significativamente sua capacidade de lidar com cenários multithread e garantir a segurança de threads em suas aplicações. Com coleções concorrentes, você pode gerenciar recursos compartilhados de forma eficaz, evitando condições de corrida e colisões entre threads.
A integração de bibliotecas externas como o IronPDF pode ampliar ainda mais a funcionalidade de coleções simultâneas, permitindo a geração de relatórios ou documentos em PDF visualmente atraentes. IronPDF oferece uma avaliação gratuita de sua biblioteca para conversão de HTML para PDF, permitindo que você explore suas capacidades, e opções de licenciamento a partir de $999.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
