Introduction

HashSet<T> is optimized for membership checks, not indexed retrieval, so the question "get the actual item" usually means something specific: you have an equal probe object and want the stored instance already inside the set. In modern .NET, the cleanest answer is TryGetValue, which lets the set locate the matching element and return the real stored object.

Use TryGetValue When You Need the Stored Instance

If the set contains an object that compares equal to your probe, TryGetValue returns that stored instance.

1using System;
2using System.Collections.Generic;
3
4var users = new HashSet<User>();
5users.Add(new User(1, "Alice"));
6
7var probe = new User(1, "IgnoredName");
8
9if (users.TryGetValue(probe, out var actualUser))
10{
11    Console.WriteLine(actualUser.Name);
12}
13
14public sealed class User : IEquatable<User>
15{
16    public int Id { get; }
17    public string Name { get; }
18
19    public User(int id, string name)
20    {
21        Id = id;
22        Name = name;
23    }
24
25    public bool Equals(User? other) => other is not null && Id == other.Id;
26    public override bool Equals(object? obj) => obj is User other && Equals(other);
27    public override int GetHashCode() => Id.GetHashCode();
28}

In that example, equality is based on Id, so the probe object is only a lookup key. The value returned in actualUser is the object already stored in the set.

Why Contains Is Not Enough

Contains tells you whether an equal item exists, but it does not return the stored instance.

1if (users.Contains(probe))
2{
3    Console.WriteLine("A matching user exists");
4}

That is useful for membership checks, but not if the stored object contains data you want to reuse, such as a canonical name, cached metadata, or additional fields the probe does not have.

Equality Rules Must Be Correct

HashSet<T> relies on equality and hash codes. If Equals and GetHashCode are inconsistent, retrieval logic will be unreliable.

The rules are:

• equal objects must produce the same hash code
• equality should reflect the identity semantics you want the set to enforce
• fields involved in equality should usually not change after insertion

Mutating a key field after insertion can make the object effectively disappear from the set's lookup perspective.

Fallback for Older Patterns

If you are on older code that does not use TryGetValue, you can still find a matching object by enumerating:

using System.Linq;

var actualUser = users.FirstOrDefault(u => u.Id == probe.Id);

This works, but it is O(n) because it scans the set linearly. The whole point of HashSet<T> is fast hash-based lookup, so TryGetValue is the better fit when available.

Know When a Dictionary Is Better

If your real use case is "look up an object by key and return the value", a Dictionary<TKey, TValue> may express the design more clearly than a HashSet<T>.

1var usersById = new Dictionary<int, User>
2{
3    [1] = new User(1, "Alice")
4};
5
6if (usersById.TryGetValue(1, out var user))
7{
8    Console.WriteLine(user.Name);
9}

Use a hash set when uniqueness of whole objects matters. Use a dictionary when keyed retrieval is the main job.

Common Pitfalls

The biggest mistake is expecting indexed access. HashSet<T> is not an ordered list, so there is no stable notion of "the element at position 3".

Another issue is implementing Equals and GetHashCode incorrectly. If the set cannot tell that two objects are equal in a consistent way, lookup methods will behave unpredictably.

People also sometimes mutate identity fields after insertion. Once the hash-relevant data changes, the object may no longer be found even though it still sits inside the set.

Finally, do not use FirstOrDefault by habit if your real intention is hash-based lookup. That throws away the performance reason for using HashSet<T> in the first place.

Summary

• Use HashSet<T>.TryGetValue to retrieve the actual stored instance that matches an equal probe.
• 'Contains only answers whether a match exists; it does not return the stored object.'
• Correct Equals and GetHashCode implementations are essential for reliable retrieval.
• Avoid mutating fields that participate in equality after insertion.
• If keyed retrieval is the primary requirement, a dictionary may be a better data structure than a hash set.