Pre-size intermediate Dictionary in ToFrozenDictionary

[AndrewP-GH]

ToFrozenDictionary builds an intermediate Dictionary<,> to deduplicate keys when the source isn't already a matching Dictionary<,>. It used the default-capacity constructor, so a known-size source pays log2(N) resizes and ~2N rehashes for nothing.

Helps most where the early source as Dictionary<,> reuse path doesn't fire: ConcurrentDictionary<,>, SortedDictionary<,>, ImmutableDictionary<,>, ReadOnlyDictionary<,>, plus arrays and List<KVP> from LINQ.

Sizing-only change — Dictionary<,> capacity is contractually behavior-invariant, so existing MultipleValuesSameKey_LastInSourceWins already covers the shared foreach { d[k] = v; } body.

[Copilot]

Pull request overview

Note

Copilot was unable to run its full agentic suite in this review.

Improves ToFrozenDictionary construction performance by pre-sizing the intermediate Dictionary when the source reports a count, and adds a regression test to ensure duplicate-key “last in wins” semantics remain intact for ICollection sources.

Changes:

• Pre-size the intermediate Dictionary<TKey, TValue> using the source collection’s count when available.
• Add a unit test covering duplicate keys for ICollection sources to prevent regressions in overwrite semantics.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 1 comment.

File	Description
src/libraries/System.Collections.Immutable/src/System/Collections/Frozen/FrozenDictionary.cs	Pre-sizes intermediate dictionary based on source count to reduce resizes/rehashes during population.
src/libraries/System.Collections.Immutable/tests/Frozen/FrozenDictionaryTests.cs	Adds regression coverage to ensure pre-sizing doesn’t change duplicate-key overwrite behavior.

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/area-system-collections
See info in area-owners.md if you want to be subscribed.

[Copilot]

Pull request overview

Copilot reviewed 2 out of 2 changed files in this pull request and generated 3 comments.

[Copilot]

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 1 comment.

[AndrewP-GH]

@dotnet-policy-service agree company="Dodo Brands"

[Copilot]

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 1 comment.

[Copilot]

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 1 comment.

[MihaZupan]

@EgorBot

using System.Collections.Concurrent;
using System.Collections.Frozen;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Collections.ObjectModel;
using System.Linq;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

BenchmarkSwitcher.FromAssembly(typeof(Bench).Assembly).Run(args);

[MemoryDiagnoser]
public class Bench
{
    [Params(16, 256, 4096)]
    public int Count { get; set; }

    private KeyValuePair<int, int>[] _array = default!;
    private List<KeyValuePair<int, int>> _list = default!;
    private ConcurrentDictionary<int, int> _concurrent = default!;
    private SortedDictionary<int, int> _sorted = default!;
    private ImmutableDictionary<int, int> _immutable = default!;
    private ReadOnlyDictionary<int, int> _readOnly = default!;

    // Duplicate-heavy source: only ~10 distinct keys, repeated Count times.
    private KeyValuePair<int, int>[] _arrayDuplicates = default!;

    [GlobalSetup]
    public void Setup()
    {
        _array = Enumerable.Range(0, Count).Select(i => new KeyValuePair<int, int>(i, i)).ToArray();
        _list = _array.ToList();
        _concurrent = new ConcurrentDictionary<int, int>(_array);
        _sorted = new SortedDictionary<int, int>(_array.ToDictionary(k => k.Key, v => v.Value));
        _immutable = ImmutableDictionary.CreateRange(_array);
        _readOnly = new ReadOnlyDictionary<int, int>(_array.ToDictionary(k => k.Key, v => v.Value));

        _arrayDuplicates = Enumerable.Range(0, Count)
            .Select(i => new KeyValuePair<int, int>(i % 10, i))
            .ToArray();
    }

    [Benchmark] public FrozenDictionary<int, int> FromArray()               => _array.ToFrozenDictionary();
    [Benchmark] public FrozenDictionary<int, int> FromList()                => _list.ToFrozenDictionary();
    [Benchmark] public FrozenDictionary<int, int> FromConcurrentDict()      => _concurrent.ToFrozenDictionary();
    [Benchmark] public FrozenDictionary<int, int> FromSortedDict()          => _sorted.ToFrozenDictionary();
    [Benchmark] public FrozenDictionary<int, int> FromImmutableDict()       => _immutable.ToFrozenDictionary();
    [Benchmark] public FrozenDictionary<int, int> FromReadOnlyDict()        => _readOnly.ToFrozenDictionary();
    [Benchmark] public FrozenDictionary<int, int> FromArrayWithDuplicates() => _arrayDuplicates.ToFrozenDictionary();
}