TaskPromiseConversion returns a Task with Status WaitingForActivation even when Promise is already resolved

[DavidBal]

Hello,

i have the following code:

internal class Program
{
    static void Main(string[] args)
    {
        //Promise Task conversion
        using (V8ScriptEngine engine = new V8ScriptEngine(V8ScriptEngineFlags.EnableTaskPromiseConversion))
        {
            engine.AddHostType("TestClass", typeof(TestClass));

            engine.Evaluate(
                """
                TestClass.executeScriptAction( async (x) => 
                {
                    return x.toLowerCase();
                }
                );
                """
                );

        }
    }
}

public static class TestClass
{
    public static void executeScriptAction(IJavaScriptObject obj)
    {
        //returns Task with Status -> TaskStatus.WaitingForActivation
        object result = obj.InvokeAsFunction("TestText");

        if (result is Task<object> resultAsTask)
        {
            //Waits forever here
            result = resultAsTask.GetAwaiter().GetResult();
        }

        Console.WriteLine(result);
    }
}

If i run this example the Promise from js is converted into a Task with the status WaitingForActivation and the code is waiting infinite for the Task to finish.
How could i receive the result of the js-function?

.csproj-File

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.ClearScript" Version="7.4.5" />
  </ItemGroup>

</Project>

With kind regards,

David

[ClearScriptLib]

Hi @DavidBal,

Promises don't support blocking waits. What you're trying to do, effectively, is get around that limitation by converting the promise to a task and then using the task's blocking wait capability. That can work, but only with major restrictions.

The key point is that a task created in this manner is bound to the promise. Only the promise's settlement callbacks can advance the task into a completed state. And those callbacks are only invoked after synchronous execution.

In your example, the blocking wait happens during synchronous execution – and on the same thread. In other words, you're waiting for the promise's settlement callbacks to complete the task, but you're also blocking the script engine from invoking them.

It might be possible to perform such a wait safely from another thread, but that would require a significant restructuring of your code. JavaScript gives you no good way to hide asynchronous code within regular, synchronous code. There's just no getting around the "contagion" of async/await.

Good luck!

[ClearScriptLib]

Hi again,

We've taken a closer look at this. It turns out that, although JavaScript doesn't provide a way to sample the state of a promise synchronously, the V8 API does.

It is therefore possible, at the point of promise-to-task conversion, to check the promise's state, and if it's settled, create a completed task that's decoupled from the promise. A quick test has confirmed that this makes your example work as expected. Similar behavior can be implemented for task-to-promise conversion.

We intend to make this change in the next ClearScript release. Please understand that it's an optimization, and we advise against relying on it, as multiple factors could derail it at runtime. For example, if the promise's result is another promise, an async function would automatically "unwrap" it under the covers and return the result of a then call, which is always in the pending state at the point of return.

Thanks!

[DavidBal]

Hi @ClearScriptLib,

thanks for your work!

I already found a way to implement it with the help of threads.

There is one little thing i need to "hack", i want to use the ScriptingEngine.Current in this new thread.

FieldInfo? currentEngineField= typeof(ScriptEngine).GetField("currentEngine", BindingFlags.Static | BindingFlags.NonPublic);

if(currentEngineField is null)
{
    throw new Exception("");
}

currentEngineField.SetValue(null, engine);

Is there a better way to do this?

Kind regards,
David

[ClearScriptLib]

Hi David,

i want to use the ScriptingEngine.Current in this new thread. [...] Is there a better way to do this?

Sorry, we aren't clear on what you're trying to do, so we can't recommend an alternative way to do it 😊

The purpose of ScriptEngine.Current is to get a reference to the engine that's executing script code on the current thread. What would be the meaning of it returning a non-null value on a thread that isn't executing script code?

Cheers!

[DavidBal]

Hi,

The purpose of ScriptEngine.Current is to get a reference to the engine that's executing script code on the current thread. What would be the meaning of it returning a non-null value on a thread that isn't executing script code?

Here a simplified example how it should looks in js.

const objectFormCSharp = new ObjectFormCSharp();

objectFormCSharp.addAction( (jsObject) => console.log('Hello World') );

await objectFormCSharp.Run(); // Start a thread in C#, this thread will invoke the 'Action' later.

In the new Thread i would like to call functions from the ScriptEngine like ScriptEngine.Current.Script.Array.from the ensure that the array is given to the js-code is a valid js-array.

    public class ObjectFormCSharp
    {
        IJavaScriptObject action;

        public ObjectFormCSharp()
        {
        }

        public void addAction(IJavaScriptObject action)
        {
            this.action = action;
        }

        public Task Run()
        {
            ScriptEngine currentEngine = ScriptEngine.Current; //Capture the current engine

            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
            Thread thread = new Thread(() => {
                try
                {
                    //inject engine into the new thread
                    FieldInfo? currentEngineField = typeof(ScriptEngine).GetField("currentEngine", BindingFlags.Static | BindingFlags.NonPublic);

                    if (currentEngineField is null)
                    {
                        throw new Exception("Das Feld für die Engine konnte nicht ermittelt werden.");
                    }

                    currentEngineField.SetValue(null, currentEngine);
                    //....

                    //DO some work here and then call the action
                    //Like start a Form that has a button that calls the action
                    tcs.SetResult(null);
                }
                catch (Exception ex)
                {
                    tcs.SetException(ex);
                }
            });

            thread.SetApartmentState(ApartmentState.STA);
            thread.Start();
            return tcs.Task;
        }

        private void executeAction()
        {
            string[] someArray = new string[] { "Test1", "Test2", "Test3" };

            action.InvokeAsFunction(someArray.ToJsArray());
        }
    }

    static class ArrayExtension
    {
        public static object? ToJsArray(this string[] @this)
        {
            if(@this == null)
            {
                return null;
            }

            if(@this.Length == 0)
            {
                return ScriptEngine.Current.Script.Array.of();
            }

            return ScriptEngine.Current.Script.Array.from(@this);
        }
    }

I hope this clarifies my goals.

Thanks again for your help!

Kind regards,
David

[ClearScriptLib]

Hi David,

Consider the following change:

static class ArrayExtension {
    public static object? ToJsArray(this string[] @this, ScriptEngine engine) {
        if (@this == null) {
            return null;
        }
        if (@this.Length == 0) {
            return engine.Script.Array.of();
        }
        return engine.Script.Array.from(@this);
    }
}

And then:

action.InvokeAsFunction(someArray.ToJsArray(action.Engine));

Let us know if that works for you.

Thanks!

[DavidBal]

Hi,

thanks.

Thats works, for this example but in some other places the call is much deeper boxed.
But I will try following your advice.

Thanks, again.

Kind regards,
David

[ClearScriptLib]

ClearScript 7.5 enhanced task-promise interop with support for pre-settled promises and pre-completed tasks.