ConcurrentDictionary and Closures in .NET

What Are Closures?

In .NET, closures are often encountered when using delegates such as Action, Func, or LINQ expressions. A closure occurs when a lambda or anonymous method captures variables from its surrounding scope. This captured state can lead to unintended behaviors, such as memory leaks or concurrency issues, especially when long-lived references exist.

Here’s a simple example to illustrate a closure:

void SayGoodbye(string name)
{
    var goodbye = () =>
    {
        // 'name' is captured, causing allocation
        Console.WriteLine($"Goodbye {name}");
    };
    goodbye();
}

In this example, the variable name is captured by the lambda function.

Problems Caused by Closures:

1. Memory Overhead: Capturing variables may require extra memory allocations, which can impact resource usage.
2. Unintended State Changes: If the captured variable is a reference type, modifications to it outside the closure can lead to unpredictable behavior.
3. Memory Leaks: Long-lived references can result in memory not being released, leading to memory leaks.

How to Avoid Closures:

Instead of capturing variables from outside the lambda’s scope, pass the necessary variables directly as arguments:

void SayGoodbye(string name)
{
    var goodbye = (string n) =>
    {
        Console.WriteLine($"Goodbye {n}");
    };
    goodbye(name);
}

This prevents capturing external variables, avoiding memory overhead and other issues related to closures.

Problem: ConcurrentDictionary and Closures

Let's take a look at an example using ConcurrentDictionary.GetOrAdd.

using System.Collections.Concurrent;

ConcurrentDictionary<string, Item> concurrentDictionary = new();

var key = "john";
var value = "great";

var result = concurrentDictionary.GetOrAdd(key, (k) => 
{
    Console.WriteLine($"Building {k}");
    return new Item(value, DateTime.Now);
});

Console.WriteLine(result);

In this example, the lambda function captures the value variable, which creates an unnecessary closure.

How to Fix the Closure

Fortunately, ConcurrentDictionary.GetOrAdd has an overload that eliminates the need for a closure.

Here’s how we can refactor the code:

using System.Collections.Concurrent;

ConcurrentDictionary<string, Item> concurrentDictionary = new();

var key = "john";
var value = "great";

var result = concurrentDictionary.GetOrAdd(
    key: key,
    valueFactory: (k, arg) =>
    {
        Console.WriteLine($"Building {k}");
        return new Item(arg, DateTime.Now);
    },
    factoryArgument: value);

Console.WriteLine(result);

record Item(string Value, DateTime Time);

In this refactored code, the lambda no longer captures external variables. Instead, we use the valueFactory parameter with two arguments:

• k for the key.
• arg for the value factory argument (the value).

This avoids creating a closure and eliminates unnecessary allocations, leading to better performance and fewer potential issues.

Whenever you use ConcurrentDictionary in .NET, particularly with GetOrAdd, check to see if you are inadvertently creating closures. If so, switch to the overload that eliminates closures by passing the required arguments directly. By doing this, you reduce memory overhead, avoid potential concurrency issues, and ensure cleaner, more efficient code.