Where and how best to store id?

[ghost]

I'm creating an MVP implementation for unity, where Jint is used as scripting for the model.
JS code looks like this

var canMove = Root["Root_BoolContainer/B_CanMove"]
var special = Root["Root_Special"]
var strength = special["I_Str"]
strength.SetValid(function(lastValue, newValue) {..Some code for valid...} )

Situation: I have string IDs (like it: "Root_BoolContainer/B_CanMove") that I would like to keep as variables. I have options for this:

1. Create a static class in C#, and then just set it as a value to the engine.
2. Use import, which executes the specified scripts in the engine in which it is running. (Yes, jint does not support import, but I created a custom import, which is intended for my MVP implementation). Then each engine will have its own set of id. And if the id is accidentally changed in one engine, it will not affect scripts in other engines.
3. Create a separate engine that will only store the ID. And when requesting an ID, the request will go from the engine to another engine.

Questions:

1. Which option is the fastest?
2. In the second case. Let's suppose 100 engines that contain 100 id's each. How much memory it take?

[lahma]

I'm probably not able to give any direct answers, especially as I haven't done any Unity development. You might want to ping the gitter chat room too with this discussion topic.

I think performance in this case is something that you need to measure. Make sure you use the v3 beta, it's much faster. Having multiple engines should be quite efficient as memory usage has been quite optimized, also if you have static script, you should compile it only once using JavaScriptParser and then pass the same Script instance to engine.

Jint will soon support dynamic import (but unfortunately it's a bit cumbersome to use via Promise while there's no await support).

You could also create a wrapper type to allow using properties via cleaner API, like const canMove = wrapper.canMove; where wrapper is a custom class that has properties and reads the source dictionary, unless you really want to pass those variables around.

[ghost]

Do I understand correctly that the two marked lines perform exactly the same actions and theoretically they should be absolutely the same in speed? If yes, then it is better to use several engines. I was afraid that in this option there might be extra castes.

Engine e1 = new Engine();
Engine e2 = new Engine();

e2.SetValue("SomeValue", e1.GetValue("SomeValue")) // this

var someValue = otherEngine.GetValue("SomeValue") // and this

[lahma]

This is a bit unsafe territory.

First, Engine is not thread safe. I'm not sure how you're going to utilize them, but keep that in mind.

Secondly, you are also sharing instances between engines and JS objects (which are not primitive types) have reference to their originating instance, I'm afraid bad/unexpected things could start to happen.

[ghost]

Thanks, I'll keep working. You helped me.