C# Concurrentdictionary (How it Works for Developers)

GetOrAdd Method: Retrieve or Add a New Key

This method checks if a specified key exists. If it doesn't, it adds the new value.

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

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

• Ensures thread safety
• Avoids duplicate rendering
• Returns associated value for the given key

AddOrUpdate Method: Handle an Existing Value Gracefully

This method allows you to update the value if the key exists, or add a new key value pair.

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

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

• Manages logic for existing key
• Ensures members accessed are safe under concurrency

TryAdd Method: Add If Key Does Not Exist

This method tries to add a value and returns a Boolean value indicating success.

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

• Perfect for avoiding conflicts
• Method returns true if insert succeeds

Use Case Table: ConcurrentDictionary Methods

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

Saved Files

Example Output

Code Breakdown

This example demonstrates how to combine ConcurrentDictionary<TKey, TValue> with IronPDF to generate PDFs in a thread-safe way. It’s perfect for apps where multiple threads are processing and caching PDF files simultaneously.

Why ConcurrentDictionary?

• Ensures thread-safe access to key-value pairs.
• GetOrAdd() avoids duplicate PDF generation.

• No manual locks needed—perfect for high concurrency. How It Works

• A list of users each has an ID and HTML.
• Parallel.ForEach spawns threads to generate PDFs.
• Each thread uses GetOrAdd() to either fetch or create the PDF.
• The PDF is saved using the user’s ID as the filename. Summary

This pattern is ideal when:

• You're generating PDFs for many users at once.
• You need performance and thread safety.
• You want clean, reliable concurrency in C#.

Try IronPDF Today

Ready to build high-performance PDF applications with full thread safety? Download a free trial of IronPDF and experience seamless PDF generation combined with the power of C#'s ConcurrentDictionary.