Optimize HashSet.UnionWith to copy data from another HashSet when empty

[Copilot]

Description

When UnionWith is called on an empty HashSet<T> with another HashSet<T> that has the same effective comparer, we can use ConstructFrom to copy the internal data structures directly instead of adding each element individually with collision checks.

// Before: iterates through all elements, computing hash and checking collisions for each
// After: copies internal arrays directly when destination is empty and comparers match
if (Count == 0 && other is HashSet<T> otherAsSet && EffectiveEqualityComparersAreEqual(this, otherAsSet))
{
    ConstructFrom(otherAsSet);
    return;
}

This mirrors the existing optimization in the HashSet constructor and is similar to Dictionary<TKey, TValue>'s AddRange optimization.

Customer Impact

Performance improvement for common pattern of clearing a HashSet and repopulating via UnionWith from another HashSet.

Regression

No, this is a new optimization.

Testing

• Added a single parameterized test HashSet_Generic_UnionWith_HashSet(int count, bool destinationEmpty, bool sourceSparseFilled) using MemberData with nested foreach loops to generate 12 combinations covering: empty/non-empty destinations, sparse-filled/normal sources, and various element counts (0, 1, 75)
• All 33,491 System.Collections tests pass

Risk

Low. Uses existing ConstructFrom method already proven in the constructor path. Optimization only triggers when destination is empty and comparers are identical.

Package authoring no longer needed in .NET 9

IMPORTANT: Starting with .NET 9, you no longer need to edit a NuGet package's csproj to enable building and bump the version.
Keep in mind that we still need package authoring in .NET 8 and older versions.

Original prompt

---

This section details on the original issue you should resolve

<issue_title>[API Proposal]: HashSet.UnionWith should copy data from another HashSet</issue_title>
<issue_description>### Background and motivation

I'll describe my specific case

        
         HashSet<ITarget> _visibleTargetsSet = new HashSet<ITarget>();
         HashSet<ITarget> _registerdTargetsSet = new HashSet<ITarget>();
         HashSet<ITarget> _safeTargetsSet = new HashSet<ITarget>();
         List<ITarget> _visibleTargets = new List<ITarget>();

        private void SetupVisibleTargets()
        {
            _visibleTargetsSet.Clear();
            _visibleTargetsSet.UnionWith(_registeredTargetsSet);
            _visibleTargetsSet.ExceptWith(_safeTargetsSet);

            _visibleTargets.Clear();
            _visibleTargets.AddRange(_visibleTargetsSet);

            _safeTargetsSet.Clear();
        }

In this example, I find the difference between the sets of registered and visible targets. _safeTargetsSet is calculated somewhere else, and registerd targets are needed to stay immutable. I don't want to create new collections, so I use clear and use _safeTargetsSet every time i need a new data for _visibleTargets. The problem is that method UnionWith is just adding every item separately with collision checks even if count is 0, unification occurs with HashSet and comparers are equal.

API Proposal

public void UnionWith(IEnumerable<T> other)
        {
            if (other == null)
            {
                throw new ArgumentNullException("other");
            }
            HashSet<T> hashSet = other as HashSet<T>;
            if (hashSet != null && Count == 0 && AreEqualityComparersEqual(this, hashSet))
            {
                // Current method ConstructFrom could be used as reference
                CopyFrom(hashSet);
                return;
            }
            foreach (T item in other)
            {
                AddIfNotPresent(item);
            }
        }

API Usage

HashSet<int> c3 = new HashSet<int>();
...

void SomeMethod()
{
    var c1 = new HashSet<int>();
    var c2 = new HashSet<int>();
    for(int i = 0; i < 100; i ++)
        c1.Add(i);
    for(int i = 0; i < 50; i ++)
        c2.Add(i);
    c3.Clear();
    c3.UnionWith(c1);
    c3.ExceptWith(c2);
}

Alternative Designs

It can be done with method overloading, not a current method change.

Risks

Idk</issue_description>

Comments on the Issue (you are @copilot in this section)

@ Tagging subscribers to this area: @dotnet/area-system-collections See info in [area-owners.md](https://github.com/dotnet/runtime/blob/main/docs/area-owners.md) if you want to be subscribed.

Issue Details

---

Background and motivation

I'll describe my specific case

        
         HashSet<ITarget> _visibleTargetsSet = new HashSet<ITarget>();
         HashSet<ITarget> _registerdTargetsSet = new HashSet<ITarget>();
         HashSet<ITarget> _safeTargetsSet = new HashSet<ITarget>();
         List<ITarget> _visibleTargets = new List<ITarget>();

        private void SetupVisibleTargets()
        {
            _visibleTargetsSet.Clear();
            _visibleTargetsSet.UnionWith(_registeredTargetsSet);
            _visibleTargetsSet.ExceptWith(_safeTargetsSet);

            _visibleTargets.Clear();
            _visibleTargets.AddRange(_visibleTargetsSet);

            _safeTargetsSet.Clear();
        }

In this example, I find the difference between the sets of registered and visible targets. _safeTargetsSet is calculated somewhere else, and registerd targets are needed to stay immutable. I don't want to create new collections, so I use clear and use _safeTargetsSet every time i need a new data for _visibleTargets. The problem is that method UnionWith is just adding every item separately with coolision checks even if count is 0, unification occurs with HashSet and comparers are equal.

API Proposal

public void UnionWith(IEnumerable<T> other)
        {
            if (other == null)
            {
                throw new ArgumentNullException("other");
            }
            HashSet<T> hashSet = other as HashSet<T>;
            if (hashSet != null && Count == 0 && AreEqualityComparersEqual(this, hashSet))
            {
                // Current method ConstructFrom could be used as reference
                CopyFrom(hashSet);
                return;
            }
            foreach (T item in other)
            {
                AddIfNotPresent(item);
            }
        }

API Usage

HashSet<int> c3 = new HashSet<int>();
...

void SomeMethod()
{
    var c1 = new HashSet<int>();
    var c2 = new HashSet<int>();
    for(int i = 0;...

</details>



<!-- START COPILOT CODING AGENT SUFFIX -->

- Fixes dotnet/runtime#92206

<!-- START COPILOT CODING AGENT TIPS -->
---

💬 We'd love your input! Share your thoughts on Copilot coding agent in our [2 minute survey](https://gh.io/copilot-coding-agent-survey).

[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

This PR optimizes HashSet<T>.UnionWith to directly copy internal data structures when called on an empty HashSet with another HashSet that has the same effective comparer, rather than iterating through elements and adding them individually.

• Adds fast-path optimization in UnionWith using existing ConstructFrom method
• Adds comprehensive test coverage for the new optimization path
• Mirrors existing optimizations in the HashSet constructor and Dictionary.AddRange

Reviewed changes

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

File	Description
src/libraries/System.Private.CoreLib/src/System/Collections/Generic/HashSet.cs	Adds optimization check before element iteration to use ConstructFrom when destination is empty and comparers match
src/libraries/System.Collections/tests/Generic/HashSet/HashSet.Generic.Tests.cs	Adds 4 new test methods covering normal sets, sparsely-filled sets, empty source, and non-empty destination fallback scenarios