如何在F＃中创建同步函数的异步版本？

Question

What are the different techniques you can use to create instances of Async<'T> in F#?

I see there are a number of extension methods for web client/request and file stream, but if I want to write my own provider of async computations, how would I go about writing those AsyncDoSomething versions of my synchronous DoSomething functions?

I know that you can use a delegate of the same signature to wrap the original function, and then use Async.FromBeginEnd on the BeginInvoke and EndInvoke methods:

open System

let del : Func<int> = new Func<int>(fun () -> 42)
let delAsync = async {
    let! res = Async.FromBeginEnd(del.BeginInvoke, del.EndInvoke)
    printfn "result was %d" res
}

Async.Start delAsync

But this feels a little forced and it doesn't seem to be the 'F# way' as you have to use delegates defined in C# or VB (of which there are plenty of System.Action and System.Func variants to choose from of course) because F# delegates don't support the BeginInvoke and EndInvoke methods.

Does anyone have a list of the different ways you can write an async version of a synchronous function in F#?

Many thanks in advance!

Answer 1

From the docs for Async , all the AwaitXXX and FromXXX methods. But the most common way is using asynchronous workflows . However, as Mauricio commented, wrapping arbitrary code with async { } isn't always beneficial.

UPDATE

Here's a bit of code to demonstrate that point.

open System.IO

let BUF_SIZE = 1 <<< 16 //64KB

let readFile f (stream:Stream) =
  let buf = Array.zeroCreate BUF_SIZE
  let rec read p =
    async {
      let! n = f stream buf 
      match n with
      | 0 -> ()
      | _ -> return! read (p + n)
    }
  read 0

let fakeAsyncReadFile s = readFile (fun stream buf -> 
  async { return stream.Read(buf, 0, buf.Length) }) s

let realAsyncReadFile s = readFile (fun stream buf -> 
  stream.AsyncRead(buf, 0, buf.Length)) s

let files = [@"C:\big_file_1"; @"C:\big_file_2"]

let readWith f = 
  let streams = Seq.map File.OpenRead files
  try Seq.map f streams |> Async.Parallel |> Async.RunSynchronously |> ignore
  finally streams |> Seq.iter (fun s -> s.Close())

readWith fakeAsyncReadFile //Real: 00:00:34.190, CPU: 00:00:03.166, GC gen0: 4, gen1: 2, gen2: 1
readWith realAsyncReadFile //Real: 00:00:05.101, CPU: 00:00:16.957, GC gen0: 31, gen1: 1, gen2: 0

Wrapping the synchronous Stream.Read with async { } yields no observable benefits. An async workflow is primarily a convenient way to chain asynchronous operations. That is, it depends on having well-written asynchronous operations to start with, to serve as building blocks.

Answer 2

And you can write like this:

let doAsyncTask  (f : unit->'a) = 
     async { return! Task<'a>.Factory.StartNew( new Func<'a>(f) ) |> Async.AwaitTask }

and use it like

let asyncFunc arg = async { return! doAsyncTask( fun () -> syncFunc arg ) } 

Answer 3

You could get some good mileage from Async.FromContinuations. That function allows you to define an Async from continuation functions. If you look at the definition of WebClient's AsyncDownloadString, you'll see this in use.