工作表達式

本文說明 F# 中的工作表示式支援,其類似於 異步表達式 ,但可讓您直接撰寫 .NET 工作。 如同異步表達式,工作運算式會以異步方式執行程序代碼,也就是不會封鎖執行其他工作。

異步程式代碼通常會使用異步表達式撰寫。 當與建立或使用 .NET 任務的 .NET 程式庫廣泛互操作時,最好使用任務表達式。 工作表達式也可以改善效能和偵錯體驗。 不過,工作表達式隨附一些限制,本文稍後會說明這些限制。

語法

task { expression }

在先前的語法中,所 expression 表示的計算會設定為以 .NET 工作的形式執行。 此工作會在執行此程序代碼後立即啟動,並在目前的線程上執行,直到第一次異步操作開始(例如異步睡眠、異步 I/O 或其他基本異步操作)。 表達式的類型為 Task<'T>,其中 'T 是使用 return 關鍵詞時表達式所傳回的類型。

使用 let! 進行繫結

在工作表達式中,有些表達式和作業是同步的,有些是異步的。 當您等待異步操作的結果時,與其使用一般的 let 綁定,不如使用 let!。 let! 的效果是使得在執行計算時,可以同時進行其他計算或執行線程。 系結右側 let! 傳回之後,其餘的工作會繼續執行。

下列程式代碼顯示 let 與 let!之間的差異。 使用 let 的程式代碼行僅僅是創建一個可以稍後等待的工作物件,比如使用 task.Wait() 或 task.Result。 使用 let! 的程式代碼行會啟動工作,並等候其結果。

// let just stores the result as a task.
let (result1 : Task<int>) = stream.ReadAsync(buffer, offset, count, cancellationToken)
// let! completes the asynchronous operation and returns the data.
let! (result2 : int)  = stream.ReadAsync(buffer, offset, count, cancellationToken)

F# task { } 運算式可以等待下列類型的異步作業:

return 運算式

在工作表達式中, return expr 用來傳回工作的結果。

return! 運算式

在工作表達式內, return! expr 用來傳回另一個工作的結果。 它相當於使用 let! ,然後立即傳回結果。

流程控制

工作運算式可以包含控制流程建構 for .. in .. do、 while .. do、、 try .. with ..、 try .. finally ..、 if .. then .. else和 if .. then ..。 這些可能會包含進一步的工作建構,但 with 與 finally 處理程式除外,這些建構會以同步方式執行。 如果您需要異步try .. finally ..,請使用use綁定配合類型為IAsyncDisposable的物件。

use 和 use! 系結

在工作表達式中,use 系結可以連接至 IDisposable 或 IAsyncDisposable 類型的值。 針對後者,會以異步方式執行處置清除作業。

除了 let!之外,您還可以使用 use! 來執行異步系結。 let! 與 use! 之間的差異與 let 與 use之間的差異相同。 針對 use!,物件會在目前範圍結束時被處置。 請注意,在 F# 6 中, use! 不允許將值初始化為空值,然而 use 則可以。

open System
open System.IO
open System.Security.Cryptography
task {
    // use IDisposable
    use httpClient = new Net.Http.HttpClient()
    // use! Task<IDisposable>
    use! exampleDomain = httpClient.GetAsync "https://example.com/data.enc"

    // use IDisposable
    use aes = Aes.Create()
    aes.KeySize <- 256
    aes.GenerateIV()
    aes.GenerateKey()
    // do! Task
    do! File.WriteAllTextAsync("key.iv.txt", $"Key: {Convert.ToBase64String aes.Key}\nIV: {Convert.ToBase64String aes.IV}")

    // use IAsyncDisposable
    use outputStream = File.Create "secret.enc"
    // use IDisposable
    use encryptor = aes.CreateEncryptor()
    // use IAsyncDisposable
    use cryptoStream = new CryptoStream(outputStream, encryptor, CryptoStreamMode.Write)
    // do! Task
    do! exampleDomain.Content.CopyToAsync cryptoStream
}

有價值的任務

值任務是用來避免在工作型程序設計中記憶體分配的結構體。 值工作是短暫的值,可以使用 .AsTask() 來轉換成實際的工作。

若要從工作運算式建立值工作,請使用 |> ValueTask<ReturnType> 或 |> ValueTask。 例如:

let makeTask() =
    task { return 1 }

makeTask() |> ValueTask<int>

and! 系結 (從 F# 10 開始)

在工作運算式中,可以同時等候多個異步作 (Task<'T>、 ValueTask<'T>Async<'T> 等) 。 比較:

// We'll wait for x to resolve and then for y to resolve. Overall execution time is sum of two execution times.
let getResultsSequentially() =
    task {
        let! x = getX()
        let! y = getY()
        return x, y
    }

// x and y will be awaited concurrently. Overall execution time is the time of the slowest operation.
let getResultsConcurrently() =
    task {
        let! x = getX()
        and! y = getY()
        return x, y
    }

新增取消令牌和取消檢查

不同於 F# 異步表示式,工作運算式不會隱含傳遞取消令牌,也不會隱含執行取消檢查。 如果您的程式代碼需要取消令牌,您應該將取消令牌指定為參數。 例如:

open System.Threading

let someTaskCode (cancellationToken: CancellationToken) =
    task {
        cancellationToken.ThrowIfCancellationRequested()
        printfn $"continuing..."
    }

如果您想要正確地實現可取消的程式碼,請仔細檢查是否將取消令牌傳遞到所有支援取消的 .NET 程式庫作業。 例如,Stream.ReadAsync 有多個重載,其中一個版本接受取消令牌。 如果您未使用此多載,該特定異步讀取作業將無法取消。

有界並行與結果管線

為了限制同時啟動的操作數量,FSharp.Core 11 提供了 Task.parallelLimit。 跳過接受取消代幣的工廠,而不是已經開始的任務:

open System.IO
open System.Threading

let readFiles (paths: seq<string>) (ct: CancellationToken) =
    paths
    |> Seq.map (fun path ->
        fun token -> File.ReadAllTextAsync(path, token))
    |> Task.parallelLimit 4 ct

結果陣列會保留輸入順序。 失敗時要求取消兄弟工作,且每個操作必須遵守其標記。 Task.sequential 工廠一台一台地運作; Task.parallelDoLimit 並且 Task.sequentialDo return unit 而非陣列。

關於 Task.map、 Task.bind、 以及 Task.catch 結果管線與匹配的非同步/ValueTask 輔助工具,請參見 非同步與任務函式。

背景任務

根據預設,如果存在,則會使用 SynchronizationContext.Current 排程 .NET 工作。 這可讓工作以協作交錯的方式作為在使用者介面執行緒上運行的代理,而不會阻塞UI。 如果不存在,則工作繼續會被排程到 .NET 執行緒集區。

實際上,產生工作的函式庫程式碼通常會忽略同步處理內容,並在需要時始終切換至 .NET 執行緒池。 您可以使用backgroundTask { }來達成此目的。

backgroundTask { expression }

背景任務會在以下意義上忽略任何 SynchronizationContext.Current:如果在具有非 Null SynchronizationContext.Current 的執行緒上啟動,則會使用 Task.Run 切換至執行緒池中的背景執行緒。 如果在具有 null SynchronizationContext.Current的線程上啟動,它會在該相同的線程上執行。

備註

實際上,這表示在 F# 工作程式代碼中通常不需要呼叫 ConfigureAwait(false) 。 相反地,打算在背景中執行的工作應該使用 backgroundTask { ... }來撰寫。 任何與背景工作相關的外部任務繫結,會在背景工作完成時重新同步至 SynchronizationContext.Current。

有關 tailcalls 的工作限制

不同於 F# 異步表示式,任務表示式不支援尾端呼叫。 也就是說,當執行 return! 時,當前的任務會被註冊為等待返回結果的任務。 這表示使用工作表達式實作的遞歸函式和方法可能會建立未系結的工作鏈結,而這些函式可能會使用未繫結的堆疊或堆積。 例如,請考慮下列程式碼:

let rec taskLoopBad (count: int) : Task<string> =
    task {
        if count = 0 then
            return "done!"
        else
            printfn $"looping..., count = {count}"
            return! taskLoopBad (count-1)
    }

let t = taskLoopBad 10000000
t.Wait()

此程式代碼撰寫樣式不應與工作運算式搭配使用,它會建立100000000個工作的鏈結,並造成 StackOverflowException。 如果在每次迴圈調用中新增異步操作,程式碼將使用基本上無限制的堆記憶體。 請考慮將此程式代碼切換為使用明確的迴圈,例如:

let taskLoopGood (count: int) : Task<string> =
    task {
        for i in count .. 1 do
            printfn $"looping... count = {count}"
        return "done!"
    }

let t = taskLoopGood 10000000
t.Wait()

如果需要異步尾遞迴,請使用支援尾遞迴的 F# 異步表達式。 例如:

let rec asyncLoopGood (count: int) =
    async {
        if count = 0 then
            return "done!"
        else
            printfn $"looping..., count = {count}"
            return! asyncLoopGood (count-1)
    }

let t = asyncLoopGood 1000000 |> Async.StartAsTask
t.Wait()

任務實施

工作是使用可繼續程式代碼實作,這是 F# 6 的新功能。 工作會由 F# 編譯程式編譯成「可繼續的狀態機器」。 這些會在 可繼續的程式代碼 RFC 和 F# 編譯程式社群會話中詳細說明。

執行時非同步實驗

建構者作者可以嘗試 .NET 執行時非同步。 編譯器產生的狀態機通常會儲存等待後繼續所需的狀態。 使用執行時非同步時,執行時會暫停並繼續執行一個特別標記的方法。

備註

此原型機採用 F# 11.2 特性。 在 .NET 11.0.100 SDK 中,啟用<LangVersion>preview</LangVersion>包含執行時非同步支援的編譯器。 同時也需要執行時與參考組件來暴露 MethodImplOptions.Async 和 System.Runtime.CompilerServices.AsyncHelpers.Await。 參考組件描述編譯時的 API;執行中的 .NET 執行環境必須實作暫停/續寫行為。

範例中已驗證的元件組合為:

Component 版本或需求
編譯器 F# 11 編譯器由 FSharp.Compiler.Service 43.13.101-rc2.26473.112提供。
FSharp.Core 封包 11.0.101-rc2.26473.112,使用 lib/net10.0/FSharp.Core.dll。 這個建構能供應; StateMachineHelpers.__runtimeAsyncReturn而 netstandard2.0 建 netstandard2.1 構則不提供。
Project 目標 net11.0。
執行時與參考組件 .NET11.0.0-rc.1.26425.128。

這些測試過的元件並非單一的 SDK 發行版。 .NET 10.0.12 會公開參考 API,但暫停/續讀檢查在其執行時會失敗。TypeLoadException 請使用上述已驗證的執行時間/參考組合;預覽模式與 API 在場皆不支援執行時。

以下呼叫網站使用應用程式定義的建構器非同步讀取檔案:

let readManifest (path: string) =
    runtimeTask {
        let! text = System.IO.File.ReadAllTextAsync path
        return text.Length
    }

建構者將計算運算式與執行時非同步的 Intrinsic 與 wait helper 連結起來。 它不是新建的內建 task 建商:

open System.Threading.Tasks
open System.Runtime.CompilerServices
open Microsoft.FSharp.Core.CompilerServices

type RuntimeTaskBuilder() =
    member inline _.Delay([<InlineIfLambda>] code: unit -> 'T) = code
    member inline _.Run([<InlineIfLambda>] code: unit -> 'T) : Task<'T> =
        StateMachineHelpers.__runtimeAsyncReturn (code())
    member inline _.Return(value: 'T) = value
    member inline _.Bind(work: Task<'T>, [<InlineIfLambda>] next: 'T -> 'U) =
        next (AsyncHelpers.Await work)

let runtimeTask = RuntimeTaskBuilder()

__runtimeAsyncReturn 標記執行時非同步的封閉方法。 在該方法中, AsyncHelpers.Await 可以暫停未完成的工作,並將控制權還給呼叫者,然後以結果繼續。 這不是封鎖 .Result 電話。

編譯器檢查支援懸掛模式;Byref 無法在暫停期間持續存在。 範例僅定義 Delay、 Run、 Return及一個 Bind 過載,並未定義具有消去、迴路或非同步處理的生產建置器。

啟用 F# 11.2 功能,定義並擴充內嵌建構器。 已經編譯 readManifest 好的 API 呼叫者不需要它。 普通 task 表達式保留其實作。 僅在執行時非同步方法內使用 AsyncHelpers.Await ;詳見 執行時非同步規範。

完整的範例專案包含一個主控台入口。 從其目錄中,使用相容的工具和可讀取的檔案執行 dotnet run -- manifest.txt 。 包含恰好 manifest的檔案,且無尾隨換行,會產生 8。 控制台入口會阻擋完成; readManifest 本身返回 Task<int>。

另請參閱