Adding getters to .NET types

[AudriusButkevicius]

I'd like to do

            engine.AddHostObject("print", new Action<object>(Console.WriteLine));
            engine.AddHostType("Unit", typeof(Unit));
            engine.Execute("Unit.__proto__.__defineGetter__('boo', function() { return 5; });");
            engine.AddHostObject("test", new Unit());
            engine.Execute("print(test.boo)");

Sadly this does not work.

What's the right way to add "extensions" to types that are then available to the proxied instances??

(Ideally it would also be Unit.prototype.__defineGetter__ rather than __proto__ as there is a ton of legacy code that relies on this)

[AudriusButkevicius]

Ok, seems this works:

            engine.AddHostObject("Unit", typeof(Unit));
            engine.Execute("Object.defineProperty(Unit, 'prototype', {get: function() { return this.__proto__ }});");
            engine.Execute("Unit.prototype.__defineGetter__('boo', function() { return 5; });");

Note that I'm adding the type as a object rather than as a type.

However, this does not seem to work:

engine.Execute("test.addFunction = function() { return 10; };");

If I make Unit type extend PropertyBag, then the boo getter disappears :/

[ClearScriptLib]

Hi @AudriusButkevicius,

The .NET and JavaScript type systems are radically different. Interception allows ClearScript to create JavaScript proxies to .NET resources, but these proxies don't follow JavaScript's prototypal inheritance conventions, which simply don't map well to .NET's type system.

However, if you're in control of the objects and types you're exposing, you can use .NET's flexibility to emulate aspects of JavaScript's model.

Conceptually, the prototype is similar to a static property, so the key is to define such a property in your classes and allow instances to dynamically "inherit" properties from the prototype.

One complication here is that any script object you hang on the prototype is specific to its parent script engine – as is the prototype itself if it's also a script object – so each class needs to manage its prototypes in a collection of some sort.

Here's a sample that demonstrates this approach. Consider the following:

public abstract class JavaScriptLikeObject : DynamicHostObject {
    protected IEnumerable<string> GetMemberNames(ClassData classData, ScriptObject obj) {
        for (; obj != null; obj = classData.ObjectCtor.InvokeMethod("getPrototypeOf", obj) as ScriptObject)
            foreach (var name in (IList)classData.ObjectCtor.InvokeMethod("getOwnPropertyNames", obj))
                yield return Convert.ToString(name);
    }
    protected bool TryGetMember(ScriptObject obj, GetMemberBinder binder, out object result) {
        if (obj.InvokeMethod("__lookupGetter__", binder.Name) is ScriptObject getter) {
            result = getter.InvokeMethod("call", this);
            return true;
        }
        return obj.TryGetMember(binder, out result);
    }
    protected class ClassData {
        public ScriptObject ObjectCtor;
        public ScriptObject Prototype;
        public ClassData() {
            ObjectCtor = (ScriptObject)ScriptEngine.Current.Global.GetProperty("Object");
            Prototype = (ScriptObject)ObjectCtor.Invoke(true);
        }
    }
}
public abstract class JavaScriptLikeObject<TDerived> : JavaScriptLikeObject {
    private static readonly ConditionalWeakTable<ScriptEngine, ClassData> classData = new ConditionalWeakTable<ScriptEngine, ClassData>();
    public static ScriptObject prototype => GetClassData().Prototype;
    public override IEnumerable<string> GetDynamicMemberNames() => GetMemberNames(GetClassData(), prototype);
    public override bool TryGetMember(GetMemberBinder binder, out object result) => TryGetMember(prototype, binder, out result);
    private static ClassData GetClassData() => classData.GetOrCreateValue(ScriptEngine.Current);
}

Note that TDerived, while not used in the code, forces the runtime to create a separate classData collection for each derived class. With this simple infrastructure in place, you can define your classes as follows:

public sealed class Unit : JavaScriptLikeObject<Unit> {
    public void hello() => Console.WriteLine("Hello from Unit!");
    public override string ToString() => "I'm a Unit!";
    // etc.
}

And now you can do things like this:

engine.AddHostType(typeof(Console));
engine.AddHostType(typeof(Unit));
engine.AddHostObject("test", new Unit());
engine.Execute(@"
    test.hello();
    Unit.prototype.foo = 123;
    Console.WriteLine(test.foo);
    Unit.prototype.__defineGetter__('boo', function () { return this.ToString(); });
    Console.WriteLine(test.boo);
    Object.defineProperty(Unit.prototype, 'zoo', { get: function() { return this.GetHashCode(); } });
    Console.WriteLine(test.zoo);
    Console.WriteLine(new Unit().zoo);
");

This is, of course, just a starting point, but hopefully it gives you an idea of what's possible.

Good luck!

[AudriusButkevicius]

This seems to take me mostly there,
the bit that doesn't work is:

engine.Execute("test.addFunction = function() { return 10; };");

I assume the way forward is to implement TrySetMember, and presumably store those somewhere?

I know I can rewrite them as defineProperty, but sadly I'm dealing with a lot of external code that I run, that I can't really change.

[ClearScriptLib]

Hi @AudriusButkevicius ,

I assume the way forward is to implement TrySetMember, and presumably store those somewhere?

Yes. Here's a more complete example that stores user-defined properties in a separate per-engine script object:

public abstract class JavaScriptLikeObject : DynamicHostObject {
    private static readonly string[] managedOverrides = { "__proto__", "__defineGetter__", "__lookupGetter__", "__defineSetter__", "__lookupSetter__" };
    private readonly ConditionalWeakTable<ScriptEngine, InstanceData> instanceData = new ConditionalWeakTable<ScriptEngine, InstanceData>();
    public ScriptObject __proto__ => GetClassData().Prototype;
    public object __defineGetter__(string name, ScriptObject func) => GetInstanceData().Properties.InvokeMethod("__defineGetter__", name, func);
    public object __lookupGetter__(string name) => GetInstanceData().Properties.InvokeMethod("__lookupGetter__", name);
    public object __defineSetter__(string name, ScriptObject func) => GetInstanceData().Properties.InvokeMethod("__defineSetter__", name, func);
    public object __lookupSetter__(string name) => GetInstanceData().Properties.InvokeMethod("__lookupSetter__", name);
    public override bool HasMember(string name, bool ignoreCase) => !managedOverrides.Contains(name) && base.HasMember(name, ignoreCase);
    public override IEnumerable<string> GetDynamicMemberNames() => GetMemberNames(GetClassData(), GetInstanceData().Properties);
    public override bool TryGetMember(GetMemberBinder binder, out object result) => TryGetMember(GetInstanceData().Properties, binder, out result);
    public override bool TrySetMember(SetMemberBinder binder, object value) => TrySetMember(GetClassData(), GetInstanceData().Properties, binder, value);
    protected abstract ClassData GetClassData();
    private InstanceData GetInstanceData() => instanceData.GetValue(ScriptEngine.Current, _ => new InstanceData(GetClassData()));
    private static IEnumerable<string> GetMemberNames(ClassData classData, ScriptObject properties) {
        for (; properties != null; properties = classData.ObjectCtor.InvokeMethod("getPrototypeOf", properties) as ScriptObject)
            foreach (var name in (IList)classData.ObjectCtor.InvokeMethod("getOwnPropertyNames", properties))
                yield return Convert.ToString(name);
    }
    private bool TryGetMember(ScriptObject properties, GetMemberBinder binder, out object result) {
        if (properties.InvokeMethod("__lookupGetter__", binder.Name) is ScriptObject getter) {
            result = getter.InvokeMethod("call", this);
            return true;
        }
        return properties.TryGetMember(binder, out result);
    }
    private bool TrySetMember(ClassData classData, ScriptObject properties, SetMemberBinder binder, object value) {
        if (classData.ObjectCtor.InvokeMethod("getOwnPropertyDescriptor", this, binder.Name) is ScriptObject descriptor && descriptor.GetProperty("set") is ScriptObject setMethod) {
            setMethod.InvokeMethod("call", this, value);
            return true;
        }
        if (properties.InvokeMethod("__lookupSetter__", binder.Name) is ScriptObject setter) {
            setter.InvokeMethod("call", this, value);
            return true;
        }
        return properties.TrySetMember(binder, value);
    }
    protected sealed class ClassData {
        public readonly ScriptObject ObjectCtor;
        public readonly ScriptObject Prototype;
        public ClassData(ScriptEngine engine) {
            ObjectCtor = (ScriptObject)engine.Global.GetProperty("Object");
            Prototype = (ScriptObject)ObjectCtor.Invoke(true);
        }
    }
    private sealed class InstanceData {
        public readonly ScriptObject Properties;
        public InstanceData(ClassData classData) {
            Properties = (ScriptObject)classData.ObjectCtor.InvokeMethod("create", classData.Prototype);
        }
    }
}
public abstract class JavaScriptLikeObject<TDerived> : JavaScriptLikeObject {
    private static readonly ConditionalWeakTable<ScriptEngine, ClassData> classData = new ConditionalWeakTable<ScriptEngine, ClassData>();
    public static ScriptObject prototype => GetStaticClassData().Prototype;
    protected sealed override ClassData GetClassData() => GetStaticClassData();
    private static ClassData GetStaticClassData() => classData.GetValue(ScriptEngine.Current, engine => new ClassData(engine));
}

And then:

engine.AddHostType(typeof(Console));
engine.AddHostType(typeof(Unit));
engine.AddHostObject("test", new Unit());
engine.Execute(@"
    test.hello();
    Unit.prototype.foo = 123;
    Console.WriteLine(test.foo);
    Unit.prototype.__defineGetter__('boo', function () { return this.ToString(); });
    Console.WriteLine(test.boo);
    Object.defineProperty(Unit.prototype, 'zoo', { get: function() { return this.GetHashCode(); } });
    Console.WriteLine(test.zoo);
    Console.WriteLine(new Unit().zoo);
    test.printGreeting = function () { Console.WriteLine(`Hi! ${this.ToString()}`); };
    test.printGreeting();
    test.__defineSetter__('qux', function (value) { Console.WriteLine(`${this.ToString()} Setting qux to ${value}!`); })
    test.qux = 'abc';
    Console.WriteLine(test.__proto__ === Unit.prototype);
");

Note that this still isn't perfect – property descriptors don't work exactly the same with these as they do with script objects – but it's pretty close. We might be able to complete the illusion with some ClearScript enhancements, but it wouldn't be easy 😁

Please let us know what you think!

[AudriusButkevicius]

Thanks for the extensive examples.

I went with a simpler thing that so far seems to satisfy my limited needs:

        private readonly Dictionary<string, object> _bag = new();

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            if (_bag.TryGetValue(binder.Name, out var obj))
            {
                result = obj;
                return true;
            }

            return TryGetMember(prototype, binder, out result);
        }


        public override bool TrySetMember(SetMemberBinder binder, object? value)
        {
            return _bag.TryAdd(binder.Name, value);
        }

Also had to plumb that into GetDynamicMemberNames, but in general it seems to do enough of what I need.
It's probably wrong a in a million ways, at which point I can revert to your examples.