Js objects/values back to C#

[KoalaBear84]

Follow up from #1479

I'm now trying the reverse, objects from Js/Jint back to C#, so from the ExternalLocaleString to LocaleString. But this is probably not working if it's a property of another object.

So for example a MyEntity class which has a LocaleString property. I've tried the SetTypeConverter, but do not get called with the IObjectConverter for the way back.

Any ideas?

Nuget packages inRiver.Remoting.iPMC and Jint.

Value before: English Text
IN  TryConvert. MyEntity MyEntity
IN  TryConvert. inRiver.Remoting.Objects.LocaleString en:English Text,nl:Nederlandse tekst
IN  TryConvert. ExternalLocaleString en:English Text,nl:Nederlandse tekst
OUT TryConvert. System.String en
Value after: English Text

I would've expected that the English text was English filled by Jint because I called myEntity.localeString['en'] = 'English filled by Jint';

using inRiver.Remoting.Objects;
using Jint;
using Jint.Native;
using Jint.Runtime.Interop;
using System.Globalization;

Engine jintEngine = new(o =>
{
	//o.Interop.Enabled = true;
	//o.Interop.TrackObjectWrapperIdentity = true;
	o.AddObjectConverter<LocaleStringToJint>();
	o.SetTypeConverter(jintEngine => new LocaleStringFromJint(jintEngine));
});

JsValue testFunction = jintEngine.Execute(
	"""
	function test(myEntity) {
		myEntity.localeString['en'] = 'English filled by Jint';
	}
	""").GetValue("test");

LocaleString localeString = new();
localeString[new CultureInfo("en")] = "English Text";
localeString[new CultureInfo("nl")] = "Nederlandse tekst";

MyEntity myEntity = new()
{
	LocaleString = localeString
};

Console.WriteLine($"Value before: {myEntity.LocaleString[new CultureInfo("en")]}");

JsValue jsValue = jintEngine.Invoke(testFunction, myEntity);

// I've expected "English filled by Jint"
Console.WriteLine($"Value after: {myEntity.LocaleString[new CultureInfo("en")]}");

Console.ReadKey();

public class MyEntity
{
	public LocaleString LocaleString { get; set; }
}

public class ExternalLocaleString : LocaleString
{
	private List<CultureInfo> _languages;

	public ExternalLocaleString(LocaleString localeString)
	{
		_languages = localeString.Languages;

		foreach (CultureInfo language in _languages)
		{
			base[language] = localeString[language];
		}
	}

	public string this[string languageCode]
	{
		get {
			CultureInfo cultureInfo = new(languageCode);

			if (ContainsCulture(cultureInfo))
			{
				return base[cultureInfo];
			}

			return null;
		}
		set {
			CultureInfo cultureInfo = new(languageCode);

			base[cultureInfo] = value;
		}
	}
}

public class LocaleStringToJint : IObjectConverter
{
	public bool TryConvert(Engine engine, object value, out JsValue result)
	{
		Console.WriteLine($"IN  TryConvert. {value.GetType().FullName} {value}");

		if (!(value is LocaleString localeString and not ExternalLocaleString))
		{
			result = null;

			return false;
		}

		result = JsValue.FromObject(engine, new ExternalLocaleString(localeString));

		return true;
	}
}

public class LocaleStringFromJint : DefaultTypeConverter
{
	public LocaleStringFromJint(Engine engine) : base(engine) { }

	public override object Convert(object value, Type type, IFormatProvider formatProvider)
	{
		Console.WriteLine($"OUT Convert. {type.FullName} {value}");

		if (type == typeof(ExternalLocaleString))
		{
			return (LocaleString)value;
		}

		return base.Convert(value, type, formatProvider);
	}

	public override bool TryConvert(object value, Type type, IFormatProvider formatProvider, out object converted)
	{
		Console.WriteLine($"OUT TryConvert. {type.FullName} {value}");

		if (type == typeof(ExternalLocaleString))
		{
			converted = (LocaleString)value;

			return true;
		}

		return base.TryConvert(value, type, formatProvider, out converted);
	}
}

[Genteure]

Let's make an equivalent of inRiver.Remoting.Objects.LocaleString so we don't need to pull in another binary.

namespace External

// Assume everything in `External` is in another library we don't control
namespace External
{
    public class LocaleString
    {
        private readonly Dictionary<CultureInfo, string?> stringMap;

        public LocaleString()
        {
            stringMap = new();
        }

        public LocaleString(Dictionary<CultureInfo, string?> stringMap)
        {
            this.stringMap = stringMap ?? throw new ArgumentNullException(nameof(stringMap));
        }

        public string? this[CultureInfo cultureInfo]
        {
            get => stringMap.ContainsKey(cultureInfo) ? stringMap[cultureInfo] : null;
            set => stringMap[cultureInfo] = value;
        }
    }

    public class Entity
    {
        public LocaleString? Name { get; set; }
    }
}

If we use the following IObjectConverter (exactly the same as the code in #1479)

code for ExternalLocaleStringConverter

public class ExternalLocaleStringConverter : IObjectConverter
{
    public bool TryConvert(Engine engine, object value, [NotNullWhen(true)] out JsValue result)
    {
        if (value is External.LocaleString localeString)
        {
            result = JsValue.FromObject(engine, new ExternalLocaleStringWrapper(localeString));
            return true;
        }
        result = null;
        return false;
    }

    private class ExternalLocaleStringWrapper
    {
        private readonly External.LocaleString _externalLocaleString;

        public ExternalLocaleStringWrapper(External.LocaleString externalLocaleString)
        {
            _externalLocaleString = externalLocaleString;
        }

        public string this[string arg]
        {
            get
            {
                CultureInfo cultureInfo = new(arg);
                return _externalLocaleString[cultureInfo];
            }
            set
            {
                CultureInfo cultureInfo = new(arg);
                _externalLocaleString[cultureInfo] = value;
            }
        }
    }
}

The following test case passes.

[Fact]
public void Test()
{
    var engine = new Engine(o => o.AddObjectConverter(new ExternalLocaleStringConverter()));

    engine.SetValue("assert", (string expected, string actual) => { Assert.Equal(expected, actual); });

    var entity = new External.Entity { Name = new External.LocaleString() };
    entity.Name[new CultureInfo("en")] = "English Name";
    entity.Name[new CultureInfo("nl")] = "I dont know Dutch :)";

    engine.SetValue("entity", entity);

    // make sure we can read from js side
    engine.Execute(" assert('English Name', entity.name['en']) ");
    engine.Execute(" assert('I dont know Dutch :)', entity.name['nl']) ");

    // update content of LocaleString
    engine.Execute(" entity.name['en'] = 'Updated Name' ");
    engine.Execute(" entity.name['nl'] = 'Hallo Wereld' ");

    // check the name have been changed
    engine.Execute(" assert('Updated Name', entity.name['en']) ");
    engine.Execute(" assert('Hallo Wereld', entity.name['nl']) ");
    Assert.Equal("Updated Name", entity.Name[new CultureInfo("en")]);
    Assert.Equal("Hallo Wereld", entity.Name[new CultureInfo("nl")]);
}

---

Edit: Downside of this approach, aside from relatively lower performance as pointed out by @lahma below, is you can't assign an instance of LocaleString to Entity.Name because from the JS side it's holding ExternalLocaleStringConverter.ExternalLocaleStringWrapper not LocaleString.

Add the following line to ExternalLocaleStringWrapper will make it able to be assigned to Entity.Name.

public static implicit operator External.LocaleString(ExternalLocaleStringWrapper v) => v._externalLocaleString;

Full code for ExternalLocaleStringConverter

public class ExternalLocaleStringConverter : IObjectConverter
{
    public bool TryConvert(Engine engine, object value, [NotNullWhen(true)] out JsValue result)
    {
        if (value is External.LocaleString localeString)
        {
            result = JsValue.FromObject(engine, new ExternalLocaleStringWrapper(localeString));
            return true;
        }
        result = null;
        return false;
    }

    private class ExternalLocaleStringWrapper
    {
        private readonly External.LocaleString _externalLocaleString;

        public ExternalLocaleStringWrapper(External.LocaleString externalLocaleString)
        {
            _externalLocaleString = externalLocaleString;
        }

        public string this[string arg]
        {
            get
            {
                CultureInfo cultureInfo = new(arg);
                return _externalLocaleString[cultureInfo];
            }
            set
            {
                CultureInfo cultureInfo = new(arg);
                _externalLocaleString[cultureInfo] = value;
            }
        }

        public static implicit operator External.LocaleString(ExternalLocaleStringWrapper v) => v._externalLocaleString;
    }
}

[Fact]
public void Assign()
{
    var engine = new Engine(o => o.AddObjectConverter(new ExternalLocaleStringConverter()));

    var entity = new External.Entity();
    var name = new External.LocaleString();
    name[new CultureInfo("en")] = "English";
    name[new CultureInfo("nl")] = "Dutch";

    engine.SetValue("entity", entity);
    engine.SetValue("name", name);

    engine.Execute(" entity.name = name ");

    Assert.Same(name, entity.Name);
}

[lahma]

One other option is to create custom IObjectWrapper, check what ObjectWrapper overrides and in your implementation just forward to instance field's indexer.

Most laborious but also most performant.

[KoalaBear84]

Yes, I completely understand removing external dependencies, good tought!

Took some time to understand why it was working now, and not before, but it is the ExternalLocaleStringWrapper part. But finally I got it working and everything is working as prefered/wanted.

Thanks you very much again! 👍