F# 生命游戏的递归函数不会异步运行_F#

F# 生命游戏的递归函数不会异步运行

F# 生命游戏的递归函数不会异步运行,f#,F#,我正在尝试运行一个函数来更新一个网格，用于一个用f#编写的生命游戏函数，所有东西都必须是递归的，没有可变项。我想通过异步运行Update函数在表单中添加一个暂停按钮，但是当我这样做时，只有一个方块被更新。但是，当我在没有异步的情况下单步执行程序时，所有的方块都会更新。你知道为什么吗 let buttonGrid : Button list list = (Startup ar);; //transform buttongrid to int grid let rec bg2ig (bg:But

我正在尝试运行一个函数来更新一个网格，用于一个用f#编写的生命游戏函数，所有东西都必须是递归的，没有可变项。我想通过异步运行Update函数在表单中添加一个暂停按钮，但是当我这样做时，只有一个方块被更新。但是，当我在没有异步的情况下单步执行程序时，所有的方块都会更新。你知道为什么吗

let buttonGrid : Button list list = (Startup ar);;

//transform buttongrid to int grid
let rec bg2ig (bg:Button list list) = 
    let rec innerLoop (bl:Button list) =
        match bl with
        |[] -> []
        |x::xs -> if (x.Name = "0") then 0::(innerLoop xs) else 1::(innerLoop xs)
    match bg with
    |[] -> []
    |y::ys -> (innerLoop y)::(bg2ig ys)

let Update (bg:Button list list)=
    let ar = (bg2ig bg)
    let rec innerUpdate (bg:Button list list)= 
        let rec arrayLoop (bl:Button list) y = 
            match bl with
            |[] -> 0
            |x::xs -> 
                let X = (15-xs.Length)
                let n = (neighbors X y ar)
                if  (ar.[X].[y] = 0) then (if n=3 then buttonGrid.[X].[y].Name<-"1") else (if (n=2||n=3)=false then buttonGrid.[X].[y].Name<-"0")
                if buttonGrid.[15-xs.Length].[y].Name="0" 
                then buttonGrid.[15-xs.Length].[y].BackColor <- Color.White 
                else buttonGrid.[15-xs.Length].[y].BackColor <- Color.Black
                arrayLoop xs y
        match bg with
        |[] -> []
        |y::ys -> 
            ignore (arrayLoop y (15-ys.Length)) 
            innerUpdate ys
    innerUpdate bg

let Running = async {
    let rec SubRun (x:int) =
        ignore (Update buttonGrid)
        if x = 1 then
            SubRun 1
        else
            0
    ignore (SubRun 1)
    do! Async.Sleep(1000)
    }

let RunAll() = 
    Running
    |> Async.RunSynchronously
    |> ignore

let buttonGrid:Button list=（启动ar）；；
//将buttongrid转换为int grid
让rec bg2ig（bg：按钮列表）=
let rec innerLoop（bl：按钮列表）=
匹配bl
|[] -> []
|x:：xs->if（x.Name=“0”）则0:（innerLoop xs）否则1:（innerLoop xs）
将bg与
|[] -> []
|y:：ys->（内部循环y）：（bg2ig ys）
让我们更新（背景：按钮列表）=
设ar=（bg2ig-bg）
let rec innerUpdate（背景：按钮列表）=
let rec arrayLoop（bl:按钮列表）y=
匹配bl
|[] -> 0
|x:：xs->
设X=（15 X.长度）
设n=（邻域X y ar）
如果（ar.[X].[y]=0），则（如果n=3，则按buttonGrid.[X].[y]。名称忽略

如注释中所述，

异步.RunSynchronously

对于此场景是一个错误的函数。它在后台线程上启动工作流（这是错误的，因为您想访问GUI元素），然后它会阻止调用线程，直到后台工作完成（这是错误的，因为您不想阻止GUI线程）

您需要使用

Async.startimimediate

在当前线程（即GUI线程）上启动工作而不阻塞。当工作流的第一部分完成时（在

Sleep

之前），GUI线程可以自由执行其他工作。在

Sleep

之后，工作流将再次在GUI线程上继续（这是通过

startimimediate

自动完成的），因此您可以再次访问GUI

另外，执行实际循环的

子运行

函数也需要是异步的-因此我希望循环的主要部分如下所示：

let Running = async {
    let rec SubRun (x:int) = 
        // Perform update and then sleep before recursive call
        ignore (Update buttonGrid)
        do! Async.Sleep(1000)
        if x = 1 then
            return! SubRun 1
        else
            return 0 }

    // Start the loop and asynchronously ignore the result
    SubRun 1 |> Async.Ignore

let RunAll() = 
    // Start the computation immediately on the current threada
    Running |> Async.StartImmediate

如注释中所述，

Async.RunSynchronously

对于这种情况是一个错误的函数。它在后台线程上启动工作流（这是错误的，因为您想访问GUI元素），然后它会阻止调用线程，直到后台工作完成（这是错误的，因为您不想阻止GUI线程）