C# Concurrentdictionary (Jak to działa dla deweloperów)

Metoda GetOrAdd: Pobierz lub dodaj nowy klucz

Ta metoda sprawdza, czy istnieje określony klucz. Jeśli nie, dodaje nową wartość.

var filePath = pdfCache.GetOrAdd(userId, id => GeneratePdfForUser(id));

var filePath = pdfCache.GetOrAdd(userId, id => GeneratePdfForUser(id));

Dim filePath = pdfCache.GetOrAdd(userId, Function(id) GeneratePdfForUser(id))

• Zapewnia bezpieczeństwo wątków
• Unika podwójnego renderowania
• Zwraca powiązaną wartość dla danego klucza

Metoda AddOrUpdate: Zarządzanie istniejącą wartością w sposób przyjazny

Ta metoda pozwala na aktualizację wartości, jeśli klucz istnieje, lub dodanie nowej pary klucz-wartość.

pdfCache.AddOrUpdate(userId,
    id => GeneratePdfForUser(id),
    (id, existingValue) => UpdatePdfForUser(id, existingValue));

pdfCache.AddOrUpdate(userId,
    id => GeneratePdfForUser(id),
    (id, existingValue) => UpdatePdfForUser(id, existingValue));

pdfCache.AddOrUpdate(userId, Function(id) GeneratePdfForUser(id), Function(id, existingValue) UpdatePdfForUser(id, existingValue))

• Zarządza logiką dla istniejącego klucza
• Zapewnia, że członkowie są dostępni w warunkach współbieżności

Metoda TryAdd: Dodaj, jeśli klucz nie istnieje

Ta metoda próbuje dodać wartość i zwraca wartość logiczną wskazującą na sukces.

bool added = pdfCache.TryAdd(userId, pdfBytes);
if (!added)
{
    Console.WriteLine("PDF already cached.");
}

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

• Idealna do unikania konfliktów
• Metoda zwraca wartość true, jeśli wstawienie się powiedzie

Tabela przypadków użycia: Metody ConcurrentDictionary

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

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

Zapisane pliki

Przykładowy wynik

Analiza kodu

Ten przykład pokazuje, jak połączyć ConcurrentDictionary<TKey, TValue> z IronPDF, aby generować PDF-y w sposób bezpieczny dla wątku. Jest idealny dla aplikacji, w których wiele wątków jednocześnie przetwarza i buforuje pliki PDF.

Dlaczego ConcurrentDictionary?

• Zapewnia bezpieczny dla wątku dostęp do par klucz-wartość.
• GetOrAdd() unika podwójnego generowania PDF.

• Nie potrzeba ręcznych blokad—idealne dla wysokiej współbieżności. Jak to działa

• Lista użytkowników, z których każdy posiada ID i HTML.
• Parallel.ForEach tworzy wątki do generowania PDF.
• Każdy wątek używa GetOrAdd(), aby pobrać lub stworzyć PDF.
• PDF jest zapisywany z użyciem ID użytkownika jako nazwy pliku. Podsumowanie

Ten wzór jest idealny, gdy:

• Generujesz PDF-y dla wielu użytkowników jednocześnie.
• Potrzebujesz wydajności i bezpieczeństwa wątków.
• Chcesz czystości i niezawodności współbieżności w C#.

Wypróbuj IronPDF już dziś

Gotowy do budowy wysokowydajnych aplikacji PDF z pełnym bezpieczeństwem wątków? Pobierz bezpłatną wersję próbną IronPDF i doświadcz płynnego generowania PDF połączonego z mocą ConcurrentDictionary w C#.