F＃執行等待在異步方法list.iteri

Question

我在下面的代碼F＃4.0

let processEscalation escalationAction (escalationEvents:UpdateCmd.Record list) = 
    printf "%A" Environment.NewLine 
    printf "Started %A" escalationAction 
    escalationEvents 
    |> List.iter (fun x -> 
     printf "%A" Environment.NewLine 
     printf "escalation %A for with action: %A" x.incident_id escalationAction 
     service.PostAction(new Models.Action(x.incident_id, escalationAction, "escalated")) 
     |> Async.AwaitTask 
     |> ignore) 


let ComposeEscalation() = 
    let escalationlevels = ["ESC1 REACHED"; "ESC2 REACHED"; "ESC3 REACHED"] 
    escalationlevels 
    |> List.map getEscalationEvents 
    |> List.iteri (fun i x -> processEscalation escalationlevels.[i] x) 

其中下面的行是該返回任務

service.PostAction(new Models.Action(x.incident_id, escalationAction, "escalated")) 

一個C＃異步方法的調用組合升級方法調用了三次processEscalation。 但是，第二個呼叫在第一個呼叫完成之前開始。 如何確保最後一行list.iteri等待並按順序處理它們？ 也許processEcalation應該是一個異步計算表達式？

Answer 1

Async.AwaitTask所做的是返回可用於等待任務完成的Async計算。就你而言，你永遠不會做任何事情，所以循環纔會繼續進行下一次迭代。

你想是這樣的：

service.PostAction(new Models.Action(x.incident_id, escalationAction, "escalated")) 
|> Async.AwaitTask 
|> Async.RunSynchronously 
|> ignore 

這應該有你所期望的效果，但肯定也有表達這種邏輯的更好，更可組合的方式。

編輯：我的意思是這樣的事情，對方的核心Async.Parallel功能：

module Async = 

    let sequential (asyncs: seq<Async<'t>>) : Async<'t []> = 
     let rec loop acc remaining = 
      async { 
       match remaining with 
       | [] -> return Array.ofList (List.rev acc) 
       | x::xs -> 
        let! res = x 
        return! loop (res::acc) xs 
      } 
     loop [] (List.ofSeq asyncs) 

然後，你可以沿着這些路線做一些事情：

escalationEvents 
// a collection of asyncs - note that the task won't start until the async is ran 
|> List.map (fun x -> 
    async { 
     let task = 
      service.PostAction(new Models.Action(x.incident_id, escalationAction, "escalated")) 
     return! Async.AwaitTask task 
    }) 
// go from a collection of asyncs into an async of a collection 
|> Async.sequential 
// you don't care about the result, so ignore it 
|> Async.Ignore 
// now that you have your async, you need to run it in a way that makes sense 
// in your context - Async.Start could be another option. 
|> Async.RunSynchronously 

的好處在這裏不是將所有東西都捆綁到一個單一的循環中，而是將計算劃分爲劃分良好的階段。這很容易遵循並重構（例如，如果您需要並行處理這些事件，則只需切換管道中的一個步驟即可）。