What is the optimal data structure for storing objects with a string key and a bool auxiliary value?

I need a data structure like below, but I need to be able to change the bool value. Other two stay the as they were when they were initialized. What would you use for best performance?

Dictionary<string, (object, bool)> dic = new Dictionary<string, (object, bool)>();

I was thinking of hashtable. But hashtable is like a dictionary with key/value. The object and bool in my example are in concept not like a key/value, because other values of the external dictionary can have the same object (or better yet ... object type). I don't want to make someone looking at my code later on thinking that the object and bool are more related they really are.

EDIT: object in this example is just a place holder. In reality it's a complex object with other objects in it and so on. Procedure before this one makes a bunch of this objects and some of them are deepcopy of the others. They are passed to this procedure. All of the object are here named by some rules and stored in the dictionary. Names are obviously unique. Procedure that comes after will take this dictionary and set the bool value on and off based on the values in the objects themselves and on the values of other bools. Procedure will be recursive until some state is reached.

Number of objects (or dic. entries) is arbitrary but expected to be >100 && <500. Time complexity is O(n).

I am targeting .NET7 (standard).

> but I need to be able to change the bool value.

You can just reassign value for the key:

var tuples = new Dictionary<string, (object Obj, bool Bool)>
{
	{ "1", (new object(), true) }
};
tuples["1"] = (tuples["1"].Obj, false); // or tuples["1"] = (tuples["1"].Item1, false);

Or

if (tuples.TryGetValue("1", out var c))
{
	tuples["1"] = (c.Obj, false);
}

Personally I would leave it at that, but for really high perf scenarios you can look into CollectionMarshall instead of second snippet:

ref var v = ref CollectionsMarshal.GetValueRefOrNullRef(tuples, "1");
if (!Unsafe.IsNullRef(ref v))
{
	v.Bool = false;
}

A bit more info - here.

For the 'performance' aspect:

The .NET Dictionary uses hashes to look up the item you need, which is very fast (comparable to a HashTable). I don't expect much performance issues related to this, or at least nothing that can be improved on with other data structures.

Also, you shouldn't worry about performance unless you are doing things a million times in a row + it turns out (in practice) that something is taking a measurable amount of time.

For the 'changing a bool' aspect:

... that is quite a long story.

There are 2 tuple variants in .NET:

• The value tuple, created by doing var x = (myObj, myBool), like you are doing.
  The x is a struct, and therefore a Value Type. You can actually change x.Item1 or x.Item2 to a new value just fine.
  However... if you put x into a Dictionary then you actually put a copy of x (with a copy of its values) into the dictionary, because that is the nature of value types.
  When you retrieve it again from the Dictionary, yet another copy is made - which makes modifying the actual tuple inside the Dictionary impossible; any attempt to do so would only modify the last copy you got.
  Side story: The .NET Compiler knows this, which is why its refuses to compile code like dic[yourKey].Item2 = newBool; because such code wouldn't do what you might hope it would do. You're basically telling the compiler to create a copy, modify the copy, and then... discard the copy. The compiler requries a variable to store the copy before the rest can even start, but we provided no variable.

• The Tuple generic class, or rather a range of generic classes, an instance of which can be created using calls like var x = Tuple.Create(myObj, myBool). These classes however forbid that you change any of their properties, they are always readonly. Tuple class instances can be put in a Dictionary, but they will still be readonly.

So what options are there really to 'modify a value in a tuple' a Dictionary?

1. Keep using a value tuple, but accept that in order to "change" the tuple inside the Dictionary you'll have to make a new instance (either a copy, or from scratch), set it to the properties that you want, and put that instance (or actualy a copy...) into the dictionary:

   // initialize it
   var dict = new Dictionary<string, (object, bool)>();
   var obj = new object();
   dict["abc"] = (obj, true);
   
   // change it
   var tmpTuple = dict["abc"]; // get copy
   tmpTuple.Item2 = false;   // alter copy
   dict["abc"] = tmpTuple;   // store another copy
   
   // or if you want to avoid the tmp variable
   dict["abc"] = (dict["abc"].Item1, false)
   

2. Use a custom class instead of the value tuple or a Tuple class, and then put that into the Dictionary:

   public class MyPair
   {
       public object O { get; set; }
       public bool B { get; set; }
   }
   
   // initialize it
   var dict = new Dictionary<string, MyPair>();
   var obj = new object();
   dict["abc"] = new MyPair { O = obj, B = true };
   
   // change it
   dict["abc"].B = false;
   

So both types of Tuples are OK for objects that you don't want to do a lot with. But both have certain limits in their usage, and sooner or later you may need to start using classes.