If these are your own classes, use a Guid to uniquely identify them and
initialize the Guid at the time the object is constructed.  If you
override the GetHashCode() method to generate a hash code based on the
value of the Guid, all the standard .Net container classes will function
as expected.

-Ted

I think you're going to have a problem however you want to do this.

Let me just talk my way through this and I'll try to explain what I mean.

First, you need to add all those objects to the container in such a way
that they can be quickly retrieved. Let's say you have something of an
"identity" value for each of those objects.

This identity value would either have to be:
- based on the values in the object
- a unique value not related to the contents of the object

Let's go with the first option and let's use the hash code of the object
as returned by GetHashCode() as this value. If, after adding an object
to a hash table, you modify the object in such a way that the hash code
returned by GetHashCode() for that object is now different from the one
used when the object was added, then yes, you have a problem.

In this context, you cannot modify the values of the keys in such a way
that the hash code changes. Put differently, the keys should be
immutable, if not enforcable then at least you should treat them as such
and not use them.

The bonus of this is that if you later on construct a wholy new object
with the same values internally as an object already present in the hash
table, then those two objects should return the same hash code and thus
you could easily detect that the object values are already in another
object in your container.

This is, as I see it, what you want.

Now, let's go with the other option. Make each object have a unique
value unrelated to the contents of the object.

This would of course make it possible for you to change the contents of
the object without messing up the hash table, as the hash code you would
use in the hash table is still the same as the original one.

However, when you later on construct a new object with the same values
as an existing object in the hash table, this new object gets a new,
unique value that will not be found in the hash table. Or, if it is
found, chances are it's not the object you're interested in, ie. another
object just happen to have that particular hash code.

Another option would be to base the hash code on the values from the
object and then cache it so that subsequent calls to GetHashCode() would
return the same value even if the contents of the object has changed.

This is also problematic regarding a hash table as it will use an
equality test once it finds the hashed values in the table to determine
which one in particular you want, and if the contents have changed...

Basically, it all comes down to one thing, the keys in the hash table
should never change. If they do then you need to take the key+value out
of the hash table and re-add it with the new key. Anything else won't work.