C#执行含Promise的JS代码：异步结果获取与处理

在.NET平台调用JavaScript脚本时，若脚本包含Promise或async/await操作，C#代码直接使用常规评估方法（如engine.Evaluate()）只会获得一个状态尚在等待中的Promise宿主对象，而无法直接拿到异步运算后的真实数据。解决该问题的核心路径在于：通过桥接机制将JavaScript的Promise生命周期（微任务就绪与敲定）转换为C#原生能够识别并await的Task<T>，同时配套完备的超时控制与异常映射。

图1：C# Task 与 JavaScript Promise 异步调度生命周期对应关系

为什么常规Evaluate无法直接获取Promise结果

JavaScript作为单线程事件循环架构，所有Promise的resolve与then链式调用均被放置在微任务队列（Microtask Queue）中排队处理。当C#引擎宿主调用同步代码解析方法（如engine.Evaluate("fetchData()")）时，脚本引擎完成的是代码的同步解释与语法树求值，此时该异步任务仅完成初始化并返回了一个处于pending状态的Promise实例。

如果C#程序直接读取返回值，得到的是一个无法直接在宿主上下文中读取业务属性的抽象宿主对象，强行调用ToString()通常只显示[object Promise]。要想获得最终计算结果，宿主必须提供持续推进引擎微任务轮转的驱动力，并在Promise状态转变为fulfilled（已解决）或rejected（已拒绝）时接收通知。

主流实现方案：以 ClearScript.V8 为例

在.NET生态中，Google V8的高性能绑定库Microsoft.ClearScript.V8是运行高负载JavaScript的工业级方案。ClearScript对动态类型支持完善，能够自然挂载宿主委托。

图2：C# 端驱动并获取 JS Promise 执行结果的标准四个环节

完整代码实现：基于TaskCompletionSource的双向桥接

下面展示如何在C#中封装一个通用的异步执行器。无论JS脚本是原生返回Promise，还是由async函数定义，都能转换为标准的Task<T>并在C#中通过await消费：

using System;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.ClearScript;
using Microsoft.ClearScript.V8;

public class JsPromiseExecutor : IDisposable
{
    private readonly V8ScriptEngine _engine;

    public JsPromiseExecutor()
    {
        // 初始化 V8 脚本引擎，开启动态宿主对象访问支持
        _engine = new V8ScriptEngine(V8ScriptEngineFlags.EnableDynamicReflection);
    }

    public async Task<object> ExecutePromiseAsync(string jsExpression, TimeSpan timeout)
    {
        var tcs = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
        using var cts = new CancellationTokenSource(timeout);

        // 注册取消标记：当超过指定时间未完成，立即终止等待
        using var registration = cts.Token.Register(() =>
        {
            tcs.TrySetException(new TimeoutException($"JavaScript Promise 执行超时（限时 {timeout.TotalMilliseconds}ms）"));
        });

        // 定义供 JavaScript 回调的 C# 委托
        Action<object> resolveCallback = result =>
        {
            tcs.TrySetResult(result);
        };

        Action<object> rejectCallback = error =>
        {
            string message = error?.ToString() ?? "未知 JavaScript 异常";
            tcs.TrySetException(new InvalidOperationException($"JS Promise Rejected: {message}"));
        };

        // 注入桥接函数到 JS 全局空间
        _engine.AddHostObject("__cs_resolve", resolveCallback);
        _engine.AddHostObject("__cs_reject", rejectCallback);

        try
        {
            // 将目标表达式用包装器包裹，自动挂接 .then 和 .catch
            string wrapperScript = $@"
                (function() {{
                    try {{
                        const target = ({jsExpression});
                        Promise.resolve(target)
                            .then(val => __cs_resolve(val))
                            .catch(err => __cs_reject(err));
                    }} catch (syncErr) {{
                        __cs_reject(syncErr);
                    }}
                }})();";

            // 执行启动包装代码
            _engine.Execute(wrapperScript);

            // 挂起 C# 线程，直至 JS 触发回调或超时
            return await tcs.Task;
        }
        finally
        {
            // 清除本轮注入的全局桥接变量，防止污染后续执行环境
            _engine.Execute("delete __cs_resolve; delete __cs_reject;");
        }
    }

    public void Dispose()
    {
        _engine?.Dispose();
    }
}

调用该执行器的使用示例如下：

public static async Task RunSample()
{
    using var executor = new JsPromiseExecutor();

    // 示例1：执行含定时模拟的 Promise
    string jsCode = @"
        new Promise((resolve) => {
            setTimeout(() => {
                resolve({ code: 200, message: '数据计算完成', values: [10, 20, 30] });
            }, 150);
        })";

    try
    {
        object rawResult = await executor.ExecutePromiseAsync(jsCode, TimeSpan.FromSeconds(3));
        dynamic data = rawResult;
        
        Console.WriteLine($"返回状态码: {data.code}");
        Console.WriteLine($"返回提示语: {data.message}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"执行失败: {ex.Message}");
    }
}

其他引擎中的 Promise 处理策略对比

除了ClearScript.V8外，纯C#编写的轻量引擎Jint以及基于WebView2的方案也在不同场景中被广泛使用。由于各底层架构不同，对Promise的处理策略存在显著差异：

图3：.NET 常见 JavaScript 运行载体对异步代码的支持差异对比

Jint 中的异步处理注意点

在纯托管的Jint 3.x中，如果直接执行异步JavaScript，由于其内部没有默认常驻的后台线程轮询，需要宿主显式驱动连续体。常见做法如下：

using Jint;

var engine = new Engine();
// 执行返回 Promise 的代码
var promise = engine.Evaluate("new Promise(res => res('Jint 结果'))");

// 在 Jint 中驱动可能存在的异步延续任务
// Jint 会在调用处同步推进微任务队列直至稳定
Console.WriteLine(promise.UnwrapIfPromise());

如果JS中包含了setTimeout等宏任务，纯托管解释器无法原生拥有操作系统时钟支持，通常建议在需要标准Promise与高负荷网络调用的场景中优先选择ClearScript。

关键陷阱与防护最佳实践

在生产环境中连接C#与JavaScript异步世界时，开发者容易在死锁、内存泄漏和错误透传三个方面遇到严重故障：

图4：生产环境运行 JS 异步任务的核心防护维度

推荐的数据序列化传递范式

直接在C#中访问V8内部对象实例虽然便捷，但在频繁跨线程或长生命周期场景下可能引发对象引用未释放的内存问题。最稳定、解耦的生产级方式是在JavaScript完成运算时统一序列化，在C#端使用System.Text.Json强类型接收：

// 优化后的包装代码：直接完成 JSON 序列化
string safeWrapper = @"
    (function() {
        Promise.resolve(" + jsExpression + @")
            .then(val => __cs_resolve(JSON.stringify(val)))
            .catch(err => __cs_reject(err instanceof Error ? err.stack : String(err)));
    })();";

string json = (string)await executor.ExecutePromiseAsync(safeWrapper, TimeSpan.FromSeconds(5));
MyTypedResult result = JsonSerializer.Deserialize<MyTypedResult>(json);

总结

在C#中处理含Promise的JavaScript代码，本质是在CLR的Task调度世界与JavaScript虚拟机的微任务队列之间搭建一座通信桥梁。掌握以下三点即可稳健应对绝大多数场景：

1. 契约转换：借助TaskCompletionSource<T>将JS中的.then()与.catch()回调转换为标准的.NET Task；
2. 非阻塞等待：全程采用await代替同步堵塞，并务必启用RunContinuationsAsynchronously以隔离线程上下文；
3. 安全边界：设置超时取消源、保留详细错误调用栈，并优先以JSON字符串完成跨语言的数据传输，保证系统的稳定性与高可用性。