Binding multiple js functions to a single C# function

[faljse]

Hi, my task is to make a native api accessible via js.

I start by registering all functions to a single catch-all method.

foreach (MethodInfo mi in methodInfos)
{
    var para = mi.GetParameters();
    FastSetProperty(mi.Name, new Jint.Runtime.Descriptors.PropertyDescriptor(new ClrFunctionInstance(Engine, mi.Name, FanucCall), false, true, false));
}
public JsValue FanucCall(JsValue thisObject, JsValue[] arguments)
{
  //Need Methodname here!
  //TODO: Use reflection to find/call native api
  return JsValue.Null;
}

This works; however without function name in the callback i dont know how to proceed.
Any hints?

[lahma]

Well Jint can also automatically wrap you object instance as exposed item, engine.SetValue("libObject", new MyTypeToExpose());.

Or could also create separate wrapper c# class that call the API you want which gives you more possibilities for exposed API, then pass that to Jint.

class TypeToExpose 
{ 
   private LibraryType myLib = new();
 
    public bool SendEmail(string email, string body)
    {
        myLib.SendEmail(new EmailAddress(email), new Body(body)); 
        return true;
    }
}

The repo has a lot of interop tests that you can explore.

[faljse]

Im working with a native api that is not fit to be used in js directly (c-style: out parameters, error return values).

Option 1 is to wrap (write a generator) all (800+) methods to a more js-friendly form.

Option 2: Do this at runtime; however i would need a way to map all registered js methods to a single c# method, dynamically searching for the required method, rewriting parameters and doing error handling.
With my current approach i cant find a way to pass the name of the called js method to the c# method.

[lahma]

I would probably choose code generation, far easier to debug too.

[Genteure]

for your option 2

// untested pseudocode in C#
public JsValue HandleNativeCall(string name, JsValue thisObject, JsValue[] arguments)
{
  // TODO: real call
  return JsValue.Null;
}

public Func<JsValue, JsValue[], JsValue> WrapHandler(string name)
{
  // return a Func that calls HandleNativeCall with the function name
  return (thisObject, arguments) => HandleNativeCall(name, thisObject, arguments);
}

engine.SetValue("hello", WrapHandler("hello"));
engine.SetValue("world", WrapHandler("world"));