What is string interning in .NET? Which strings are interned automatically, how do string.Intern and string.IsInterned work, and when is interning useful or harmful?

1. Where the intern pool lives

The CLR maintains a global string literal map (historically per AppDomain in .NET Framework, process-wide in .NET Core). Entries are strong references, so interned strings are effectively GC roots — they are never collected while the runtime is alive.

When the JIT compiles a method containing ldstr "OK":

1. It looks up the literal in the module's string table.
2. It checks the global map; if absent, it allocates the string and registers it.
3. The JIT embeds the address (or a handle) of the canonical object into the machine code, so loading a literal at run time is essentially a constant load — no lookup per execution.

.NET 8 moved string literals onto the Frozen Object Heap (a non-GC heap): they are never moved or collected, so the JIT can hard-code their address directly.

2. Cost of string.Intern

Each call:

• Computes a hash over the entire string (O(length)).
• Takes a lock on the global table.
• Compares against existing entries in the bucket.
• Possibly registers a new entry.

For a 50-character string this is far more expensive than a plain equality comparison, and under concurrency the lock becomes a contention point. Interning only pays off when the memory savings over the lifetime of the data dwarf the lookup cost.

3. CompilationRelaxations.NoStringInterning

The C# compiler marks assemblies with [CompilationRelaxations(8)] (NoStringInterning), which permits the runtime not to intern literals across assemblies. In practice CoreCLR still interns literals, but the specification does not guarantee that literals from two different assemblies are the same instance. Never write code that depends on cross-assembly reference identity of literals.

4. Reference equality and string.Equals

string.Equals(a, b) (and ==) first checks ReferenceEquals(a, b) and returns true immediately, then checks lengths, then compares characters with vectorised SIMD code. So:

• Equal interned strings compare in one pointer check.
• Equal non-interned strings compare in O(length) with SIMD, which is extremely fast for typical lengths.
• Unequal strings of different length are rejected after the length check.

The practical benefit of interning for comparison speed is therefore small; its real benefit is memory.

5. Building your own de-duplication pool

public sealed class StringDeduplicator
{
    private readonly HashSet<string> _pool = new(StringComparer.Ordinal);

    public string Get(string value)
    {
        if (_pool.TryGetValue(value, out var existing)) return existing;   // canonical instance
        _pool.Add(value);
        return value;
    }

    public string Get(ReadOnlySpan<char> span)
    {
        var lookup = _pool.GetAlternateLookup<ReadOnlySpan<char>>();       // .NET 9+
        if (lookup.TryGetValue(span, out var existing)) return existing;   // no allocation on a hit
        var created = span.ToString();
        _pool.Add(created);
        return created;
    }
}

.NET 9's alternate lookup (GetAlternateLookup<ReadOnlySpan<char>>) lets you look up strings by span without allocating a temporary string first — ideal when parsing from a buffer. Because the pool is an ordinary object, it is collected when you drop it (for example with the old cache on refresh), unlike the intern pool. For multi-threaded use, wrap it in a lock or use a concurrent/bounded pool such as CommunityToolkit's StringPool.

6. Runtime-level de-duplication

Java's G1 garbage collector can de-duplicate string contents automatically. The .NET GC does not do this by default, so in .NET de-duplication is an application-level decision: scoped pools, FrozenSet/enums for closed vocabularies, or interning for small fixed sets. If you see a runtime option advertised for this in a newer .NET release, treat it as something to verify against the official runtime documentation and measure under load before enabling it in production.

7. Diagnosing duplicate strings

• dotnet-dump collect then dotnet-dump analyze → dumpheap -stat shows total System.String count and size; dumpheap -type System.String -min 100 lists large ones.
• Visual Studio's managed memory analysis has a duplicate strings view.
• JetBrains dotMemory has a "Duplicate strings" inspection showing wasted bytes per value.

Try it yourself

1. Read 1,000,000 lines with repeated values into a List<string>, take a snapshot with dotMemory or dotnet-gcdump, then de-duplicate with a pool and compare.
2. Call string.IsInterned on a literal and on a runtime-built string.
3. Benchmark string.Intern vs a HashSet<string> pool with 8 threads.
4. Use GetAlternateLookup<ReadOnlySpan<char>> to look up strings from a span without allocating.

namespace Strings;

public sealed record Product(string Sku, string Brand, string State);

// Scoped pool: deduplicates values for one load and is then collected
public sealed class LoadScopedStringPool
{
    private readonly HashSet<string> _pool = new(StringComparer.Ordinal);

    public string Get(string value)
    {
        if (_pool.TryGetValue(value, out var existing)) return existing;
        _pool.Add(value);
        return value;
    }
}

public static class Interning
{
    public static void Main()
    {
        string literal1 = "NSW";
        string literal2 = "NSW";
        string runtime = new string(['N', 'S', 'W']);             // built at run time

        Console.WriteLine(ReferenceEquals(literal1, literal2));   // True
        Console.WriteLine(ReferenceEquals(literal1, runtime));    // False
        Console.WriteLine(literal1 == runtime);                   // True (content)
        Console.WriteLine(string.IsInterned(runtime) is not null); // True: an equal literal is pooled

        string pooled = string.Intern(runtime);
        Console.WriteLine(ReferenceEquals(literal1, pooled));     // True

        // Reference comparison bug: works for literals, fails for runtime strings
        object x = literal1, y = runtime;
        Console.WriteLine(x == y);                                // False: object == compares references

        // Safer deduplication for a bulk load
        var pool = new LoadScopedStringPool();
        var products = new List<Product>();
        foreach (var (sku, brand, state) in ReadRows())
        {
            products.Add(new Product(sku, pool.Get(brand), pool.Get(state)));
        }
        Console.WriteLine(ReferenceEquals(products[0].State, products[1].State)); // True
    }

    private static IEnumerable<(string Sku, string Brand, string State)> ReadRows()
    {
        // Simulates values coming from a file or database: a new instance on every row
        for (int i = 0; i < 3; i++)
            yield return ($"SKU{i}", new string(['A', 'c', 'm', 'e']), new string(['V', 'I', 'C']));
    }
}