F# 如何等待异步方法，类似于C#

如何在F#中进行简单的等待

在C#中，我有如下代码：

await collection.InsertOneAsync(DO);
var r = collection.ReplaceOneAsync((fun d -> d.Id = DO.Id), DO)

let myAsyncFunction () = async {
  let! _ = collection.InsertOneAsync(DO) |> Async.AwaitTask
  let r = collection.ReplaceOneAsync((fun d -> d.Id = DO.Id), DO) 
  // More code goes here
}

因此，我创建了一个let await=…，使我的F代码与我的C代码更加相似

我目前的F#代码如下：

let awaits (t: Threading.Tasks.Task) = t |> Async.AwaitTask |> Async.RunSynchronously
let await (t: Threading.Tasks.Task<'T>) = t |> Async.AwaitTask |> Async.RunSynchronously


let Busca (numero) = 
    let c = collection.Find(fun d -> d.Numero=numero).ToList()
    c

let Insere(DO: DiarioOficial) =
    //collection.InsertOneAsync(DO) |> Async.AwaitTask |> Async.RunSynchronously
    collection.InsertOneAsync(DO) |> awaits

let Salva (DO: DiarioOficial) =
    //let r = collection.ReplaceOneAsync((fun d -> d.Id = DO.Id), DO) |> Async.AwaitTask |> Async.RunSynchronously
    let r = collection.ReplaceOneAsync((fun d -> d.Id = DO.Id), DO) |> await
    r

我该怎么做

在F#中，我们倾向于使用另一种语法。此处对其进行了描述，例如：

或在此：

使用C#任务的想法是将它们“转换”为异步

你可能可以用另一种方式来做，但这是最简单的。

在F#中，我们倾向于使用另一种语法。此处对其进行了描述，例如：

或在此：

使用C#任务的想法是将它们“转换”为异步

---

您可能可以用另一种方法来完成，但这是最简单的。

用F和C编写异步代码有两个部分

• 您需要将方法或代码块标记为异步。在C#中，这是使用

  async

  关键字完成的。F#等价物是使用

  async{…}

  块（这是一个表达式，但在其他方面类似）

• 在

  async

  方法或

  async{..}

  块中，可以进行非阻塞调用。在C#中，这是使用

  wait

  完成的，在F#中，这是使用

  let。请注意，这不仅仅是一个函数调用——编译器以一种特殊的方式处理它
  

F#也使用

Async

类型而不是

Task

，但这些类型很容易转换-例如使用

Async.Async.Task

。所以，你可能想要这样的东西：

await collection.InsertOneAsync(DO);
var r = collection.ReplaceOneAsync((fun d -> d.Id = DO.Id), DO)

let myAsyncFunction () = async {
  let! _ = collection.InsertOneAsync(DO) |> Async.AwaitTask
  let r = collection.ReplaceOneAsync((fun d -> d.Id = DO.Id), DO) 
  // More code goes here
}

我用了

let

来显示这个想法，但是如果您有一个异步操作返回

单元

，您也可以使用

do

do! collection.InsertOneAsync(DO) |> Async.AwaitTask

在F#和C#中编写异步代码分为两部分


您需要将方法或代码块标记为异步。在C#中，这是使用
async
关键字完成的。F#等价物是使用
async{…}
块（这是一个表达式，但在其他方面类似）

在
async
方法或
async{..}
块中，可以进行非阻塞调用。在C#中，这是使用
wait
完成的，在F#中，这是使用
let。请注意，这不仅仅是一个函数调用——编译器以一种特殊的方式处理它


F#也使用
Async
类型而不是
Task
，但这些类型很容易转换-例如使用
Async.Async.Task
。所以，你可能想要这样的东西：

await collection.InsertOneAsync(DO);
var r = collection.ReplaceOneAsync((fun d -> d.Id = DO.Id), DO)

let myAsyncFunction () = async {
  let! _ = collection.InsertOneAsync(DO) |> Async.AwaitTask
  let r = collection.ReplaceOneAsync((fun d -> d.Id = DO.Id), DO) 
  // More code goes here
}

我用了
let
来显示这个想法，但是如果您有一个异步操作返回
单元
，您也可以使用
do

do! collection.InsertOneAsync(DO) |> Async.AwaitTask

没有一个像我想做的那样有一个简单的let-await语句，没有一个像我想做的那样有一个简单的let-await语句。