💾 Feat(Compiler): 直接将脚本转换为可编译C#脚本并直接预编译，运行提速10000x(使用BrainFuck编译器脚本测试)

Author: StardustSeemsInk

KitX Clients/KitX Core/KitX.Core.BluePrint.Test/Program.cs

@@ -156,6 +156,14 @@ public static void Main(string[] args)
             Console.WriteLine("└──────────────────────────────────────────┘\n");
             RunExecutionTest(converter, reverseConverter, parser, sp, GetRawNestedScript(), helpers, "Test K");
         }
+
+        if (ShouldRunTest("L"))
+        {
+            Console.WriteLine("\n┌──────────────────────────────────────────┐");
+            Console.WriteLine("│ Test L: Assembly Compilation             │");
+            Console.WriteLine("└──────────────────────────────────────────┘\n");
+            RunAssemblyCompilationTest(reverseConverter, parser, sp);
+        }
     }
 
     private static void ParseArgs(string[] args)
@@ -366,6 +374,106 @@ private static void RunExecutionTest(
         }
     }
 
+    // Test L: Assembly Compilation
+    // ──────────────────────────────────────────────
+    private static void RunAssemblyCompilationTest(
+        IBlueprintToBlockScriptConverter reverseConverter,
+        IBlockScriptParser parser,
+        System.IServiceProvider sp)
+    {
+        try
+        {
+            var sourceCode = @"#ConstBlock
+int count = 0;
+int max = 3;
+
+#MainBlock
+Set(""count"", 0);
+NextBlock = ""LoopBlock"";
+
+#Block LoopBlock
+NextBlock = Loop(HelperFuncCompare(""BLT"", Get(""count""), max), ""PrintBlock"", ""EndBlock"");
+
+#Block PrintBlock
+Print(Get(""count""));
+Set(""count"", HelperFuncAdd(Get(""count""), 1));
+NextBlock = ToLoopCond(""LoopBlock"");
+
+#Block EndBlock
+Print(""Done"");
+";
+
+            var parseResult = parser.Parse(sourceCode);
+            if (!parseResult.IsSuccess || parseResult.Script == null)
+            {
+                Console.WriteLine("[Test L] FAILED: Parse error: " + parseResult.ErrorMessage);
+                return;
+            }
+
+            parseResult.Script.HelperFunctions = GetExecutionHelpers();
+
+            // Test 1: Direct ScriptAssemblyCompiler test
+            var compiler = new ScriptAssemblyCompiler();
+            Console.WriteLine("[Test L] Compiling...");
+            var compiled = compiler.CompileScript(parseResult.Script);
+            Console.WriteLine($"[Test L] Assembly compilation: {(compiled != null ? "SUCCESS" : "FAILED (null)")}");
+
+            if (compiled != null)
+            {
+                // Test 2: Execute via compiled assembly
+                var output = new List<string>();
+                var globals = new BlockScriptExecutionGlobals(
+                    new BlockScopeManager(), output);
+                globals.ResetRunState();
+
+                Console.WriteLine("[Test L] About to call Run()...");
+                using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(2));
+                try
+                {
+                    compiled.Run(globals, cts.Token);
+                    Console.WriteLine($"[Test L] Assembly execution: SUCCESS");
+                    Console.WriteLine($"[Test L] ExecutedBlockCount: {globals.ExecutedBlockCount}");
+                    Console.WriteLine($"[Test L] Output: [{string.Join(", ", output)}]");
+                }
+                catch (OperationCanceledException)
+                {
+                    Console.WriteLine("[Test L] Assembly execution: TIMEOUT (infinite loop?)");
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"[Test L] Assembly execution: EXCEPTION - {ex.GetType().Name}: {ex.Message}");
+                    if (ex.InnerException != null)
+                        Console.WriteLine($"  Inner: {ex.InnerException.GetType().Name}: {ex.InnerException.Message}");
+                }
+            }
+
+            // Test 3: Compare via IBlockScriptExecutor (should use assembly path)
+            var executor = sp.GetRequiredService<IBlockScriptExecutor>();
+            using var cts2 = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+            var result = executor.ExecuteAsync(parseResult.Script, cancellationToken: cts2.Token)
+                .GetAwaiter().GetResult();
+            Console.WriteLine($"[Test L] IBlockScriptExecutor: IsSuccess={result.IsSuccess}, BlockCount={result.ExecutedBlockCount}");
+            Console.WriteLine($"[Test L] Executor output ({result.Output.Count} lines): [{string.Join(", ", result.Output)}]");
+
+            // Verify output matches expected: 0, 1, 2, Done
+            var expected = new List<string> { "0", "1", "2", "Done" };
+            bool match = result.IsSuccess && result.Output.Count == expected.Count;
+            if (match)
+            {
+                for (int i = 0; i < expected.Count; i++)
+                {
+                    if (result.Output[i] != expected[i]) { match = false; break; }
+                }
+            }
+
+            Console.WriteLine($"[Test L] {(match ? "PASS - Output correct!" : (result.IsSuccess ? "DIFF" : "FAILED"))}");
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"[Test L] FAILED: {ex.Message}\n  {ex.StackTrace}");
+        }
+    }
+
     /// <summary>
     /// Helper functions with actual execution bodies (for execution test).
     /// </summary>

KitX Clients/KitX Core/KitX.Core/Workflow/BlockScripting/BlockScriptExecutionGlobals.cs

@@ -24,6 +24,12 @@ public class BlockScriptExecutionGlobals
     /// </summary>
     public string? NextBlock { get; set; } = null;
 
+    /// <summary>
+    /// Number of blocks executed so far in the current run.
+    /// Incremented at the start of each block's switch case in the compiled assembly path.
+    /// </summary>
+    public int ExecutedBlockCount { get; set; }
+
     /// <summary>
     /// Creates script globals
     /// </summary>
@@ -55,6 +61,20 @@ public dynamic Get(string name)
         return _scopeManager.ResolveVariable(name)!;
     }
 
+    /// <summary>
+    /// Gets a variable value typed as <typeparamref name="T"/>.
+    /// Used by the compiled assembly path to avoid <c>dynamic</c> binding overhead.
+    /// Performs standard unboxing/conversion, no <c>Microsoft.CSharp.RuntimeBinder</c> needed.
+    /// </summary>
+    public T? Get<T>(string name)
+    {
+        if (name == "NextBlock")
+            return (T?)(object?)NextBlock;
+        if (_variables.TryGetValue(name, out var value))
+            return (T?)value;
+        return (T?)_scopeManager.ResolveVariable(name);
+    }
+
     /// <summary>
     /// Sets a variable value
     /// </summary>
@@ -140,7 +160,11 @@ public void Pause(int milliseconds)
     /// <summary>
     /// Resets run-level state (called when execution starts from Entry node)
     /// </summary>
-    public void ResetRunState() => _flipCounter = 0;
+    public void ResetRunState()
+    {
+        _flipCounter = 0;
+        ExecutedBlockCount = 0;
+    }
 
     /// <summary>
     /// Flip — alternating control flow. Routes to outputA on odd calls, outputB on even calls.

KitX Clients/KitX Core/KitX.Core/Workflow/BlockScripting/BlockScriptExecutor.cs

@@ -45,6 +45,9 @@ public class BlockScriptExecutor : IBlockScriptExecutor
     private Dictionary<string, string>? _blockCodeCache;
     private HashSet<string>? _predeclaredVariables;
 
+    // Full-script assembly compilation
+    private readonly ScriptAssemblyCompiler _assemblyCompiler = new();
+
     /// <summary>
     /// Creates a new block script executor
     /// </summary>
@@ -91,6 +94,46 @@ public async Task<BlockScriptExecutionResult> ExecuteAsync(
 
         try
         {
+            // ── Fast path: Full-script assembly compilation ──
+            // Try to compile the entire script into a .NET assembly and run it directly.
+            // This eliminates all per-block CSharpScript overhead (ContinueWithAsync).
+            // On failure, falls back to the existing CSharpScript execution path.
+            try
+            {
+                var compiled = _assemblyCompiler.CompileScript(script);
+                if (compiled != null)
+                {
+                    Log.Debug("[BlockScriptExecutor] Using assembly-compiled execution path");
+                    _globals = new BlockScriptExecutionGlobals(_scopeManager, _output, _pluginManager);
+                    _globals.ResetRunState();
+                    _scopeManager.InitializeGlobalScope(script);
+
+                    // Import parameters
+                    if (parameters != null)
+                    {
+                        foreach (var p in parameters)
+                            _globals.Set(p.Key, p.Value);
+                    }
+
+                    compiled.Run(_globals, cancellationToken);
+
+                    _stopwatch.Stop();
+                    return new BlockScriptExecutionResult
+                    {
+                        IsSuccess = true,
+                        ExecutedBlockCount = _globals.ExecutedBlockCount,
+                        ExecutionTimeMs = _stopwatch.ElapsedMilliseconds,
+                        Output = _output
+                    };
+                }
+            }
+            catch (OperationCanceledException) { throw; }
+            catch (Exception ex)
+            {
+                Log.Warning(ex, "[BlockScriptExecutor] Assembly compilation failed, falling back to CSharpScript");
+            }
+
+            // ── Fallback path: CSharpScript execution (per-block) ──
             // Store script reference for use in EvaluateExpressionAsync
             _currentScript = script;
 

KitX Clients/KitX Core/KitX.Core/Workflow/BlockScripting/ICompiledBlockScript.cs

@@ -0,0 +1,21 @@
+using System.Threading;
+using KitX.Core.Contract.Workflow;
+
+namespace KitX.Core.Workflow.BlockScripting;
+
+/// <summary>
+/// Represents a BlockScript compiled into a .NET assembly via Roslyn CSharpCompilation.
+/// The <c>Run</c> method executes the entire script in a single JIT-compiled method call,
+/// eliminating all per-block CSharpScript overhead.
+/// </summary>
+public interface ICompiledBlockScript
+{
+    /// <summary>
+    /// Executes the compiled script using the provided globals and cancellation token.
+    /// The method contains a <c>while(true) + switch(NextBlock)</c> dispatcher that
+    /// runs all blocks until the script naturally terminates or is cancelled.
+    /// </summary>
+    /// <param name="globals">Execution globals providing built-in functions and variable storage.</param>
+    /// <param name="cancellationToken">Token for cooperative cancellation.</param>
+    void Run(BlockScriptExecutionGlobals globals, CancellationToken cancellationToken);
+}