Invalidation of atom (...) in watched scope (...) is dangerous.

[Girildo]

Hi everyone!
I love this library and I am using it to build my game.

I created a UI component with some state marked as [Atom] and upon its distruction I see
Invalidation of atom (...) in watched scope (...) is dangerous

I am not sure what causes this and how to prevent it.
Can anyone give me any pointer?

Thank you in advance and keep up the good work!

[vanifatovvlad]

Hi,

the message Invalidation of atom (X) in watched scope (Y) is dangerous means that you are changing the value of an X atom during the evaluation of another Y atom (computed or reaction). The simplest case is:

[Atom] public int X { get; set; }

Atom.Reaction(() => X = 123, debugName: "Y");

Detailed

There are three types of atoms in the library: Value, Computed and Reaction:

• Value atoms must changed as a result of user actions;
• Computed atoms must be evaluated based on other computed atoms and value atoms;
• Reactions are designed to trigger side effects, such as updating the user interface.

However sometimes due to programmer mistake it turns out that the value of atoms is changed directly during the execution of the reaction. For example, this will happen in the following code:

public Toggle toggle;

[Atom] public bool IsActive { get; set; }
[Atom] public int Counter { get; set; }

toggle.onValueChanged.AddListener(() => Counter = Counter + 1);

Atom.Reaction(() => toggle.isOn = IsActive );

The Reaction will change the value of toggle.isOn. Changing this value will immediately trigger the onValueChanged callback. In this callback the Counter variable will be read. As a result, the value of the reaction will be recalculated both when the value of the IsActive atom changes (as expected), but also when the value of Counter changes (which is completely unexpected).

Solution

To solve the problem, you need to wrap the code that changes the state of the atoms in NoWatch.

For example, in the UniMob.UI framework all callbacks from UGUI wrapped into NoWatch.

I also recommend wrapping all calls to code that we do not control. For example:

Atom.Reaction(() => {
   var tmp = IsActive;
   using (Atom.NoWatch) {
      otherGameObject.SetActive(tmp);
   }
})

//same as
Atom.Reaction(() => IsActive, tmp => otherGameObject.SetActive(tmp));

If there is a read of atoms in otherGameObject's Awake, then there will be a situation similar to the example above. Alternatively you can strictly control which functions can access atoms and which cannot to avoid this situations.

If this is not your case, please provide an example of the code.

[Girildo]

Ah I see.
I am actually using it with UniMob.UI and I ran into the problem.
Thank you very much for the explanation. They're both amazing libraries ⭐