WASM - How to Correctly Use Low-Level Javascript Interop APIs

[legistek]

First off, I've not been able to find any real documentation on the low-level Javascript APIs (such as these https://github.com/dotnet/runtime/blob/360df71eadde0d1394ee7b89693f83913f75575d/src/mono/wasm/runtime/binding_support.js) so apologies if I missed something. If there is documentation somewhere I'd hugely appreciate pointing me in the right direction.

Barring that, I have a few questions about low-level interop and specifically the idea of passing Mono object references to and from JS.

Suppose I do something like this:

C#:

MyObject _myObject = new MyObject();

void SendToJS()
{
     InternalCalls.InvokeJSUnmarshalled<MyObject, object, object, object>(
          "window.myJavascriptFunction", 
          _myObject, null, null);
}

TS:

_myCSObject: System_Object|null = null;
window.myJavascriptFunction = function(obj: System_Object) => 
{
   // obj is actually just a number (address?)
   _myCSObject = obj;
};

Later (TS):

var myMethod = (window as any).Module.bind_static_method('[MyAssembly] MyNamespace.MyStaticClass:MyMethod', 'm');  // signature 'm' for raw mono object (which I'm supposed to only use if I "know what [I'm] doing" - which is exactly the state of mind I'm trying to achieve :)
myMethod(_myCSObject);

Finally (C#):

public static class MyStaticClass 
{
    public static MyMethod(MyObject obj) 
    {
        // obj is populated with the original myObject
    }
}

So - the above all works - impressively! But I'm nervous it's too good to be true and will come back to bite me. Thus, my questions:

• What exactly is being passed into myJavascriptFunction? I know it's a number, but what does it represent? A memory address? Some kind of internal object handle?
• How long is it safe to use this value with future calls into C#? I thought one of the main issues with using pointers in .NET is that addresses can change after a GC and thus you need to use them inside a fixed block. But this feels like I'm getting around that and so I'm not confident a GC or something else won't cause that number to be invalid at some future point.
• Assuming it is safe to hold onto that pointer and use it later, should I basically treat it as a weak reference to _myObject? Or am I actually preventing GC of the original object by giving it to Javascript?
• Assuming it is a weak reference, what would happen if MyMethod were called after _myObject is garbage collected? Would obj just be null or would everything blow up?
• Slightly different but related topic - when functions like mono_obj_array_new and js_string_to_mono_string are used, which create managed objects, at what point do they become eligible for garbage collection? If I call them and never actually pass the objects back to C# do they just get collected on the next GC?

Many thanks for any assistance!

[legistek]

Is there really no one able or willing to answer some of these questions? Would the folks in AspNetCore / Blazor be more knowledgeable here?

[pavelsavara]

I guess you are asking from Net6.0 perspective.
Some of the code you are referring to is part of Blazor codebase and internal.

Note that the API for dotnet JavaScript are currently changing for Net7.0 and they are not "Shipped API" (long term commitment) at this time. I'm preparing samples of the usage of new API here #62292

[legistek]

Yeah I am asking about .NET6. I'm only using Blazor to gain access to the WASM SDK which is no longer available on its own. Would love for that to change. Thanks for that info, I will take a look!