Async.RunSynchronously<'T> Method (F#)
Runs the asynchronous computation and awaits its result.
Namespace/Module Path: Microsoft.FSharp.Control
Assembly: FSharp.Core (in FSharp.Core.dll)
// Signature: static member RunSynchronously : Async<'T> * ?int * ?CancellationToken -> 'T // Usage: Async.RunSynchronously (computation) Async.RunSynchronously (computation, timeout = timeout, cancellationToken = cancellationToken)
If an exception occurs in the asynchronous computation then an exception is re-raised by this function. If no cancellation token is provided then the default cancellation token is used. The timeout parameter is given in milliseconds. A value of -1 is equivalent to Infinite.
Async.RunSynchronously should not be used on the main thread in asynchronous programming environments, such as in Silverlight-based applications.
The following example shows how to use Async.RunSynchronously to run an asynchronous computation created by using Async.Parallel, with no timeout.
let bufferData (number:int) = [| for count in 1 .. 1000 -> byte (count % 256) |] |> Array.permute (fun index -> index) let writeFile fileName bufferData = async { use outputFile = System.IO.File.Create(fileName) do! outputFile.AsyncWrite(bufferData) } Seq.init 1000 (fun num -> bufferData num) |> Seq.mapi (fun num value -> writeFile ("file" + num.ToString() + ".dat") value) |> Async.Parallel |> Async.RunSynchronously |> ignore
The following example shows how to use Async.RunSynchronously with a timeout.
let bufferData (number:int) = [| for i in 1 .. 1000 -> byte (i % 256) |] |> Array.permute (fun index -> index) // Create a counter as a reference cell that can be modified in parallel. let counter = ref 0 // writeFileInner writes the data to an open stream // that represents the file. It also updates the counter. // The counter is locked because it will be accessed by // multiple asynchronous computations. // The counter must be updated as soon as the // AsyncWrite completes, in the same synchronous // program flow. There must not be a let! or do! between // the AsyncWrite call and the counter update. let writeFileInner (stream:System.IO.Stream) data = let result = stream.AsyncWrite(data) lock counter (fun () -> counter := !counter + 1) result // writeFile encapsulates the asynchronous write operation. // The do! includes both the file I/O operation and the // counter update in order to keep those operations // together. let writeFile fileName bufferData = async { use outputFile = System.IO.File.Create(fileName) do! writeFileInner outputFile bufferData // Updating the counter here would not be effective. } let async1 = Seq.init 1000 (fun num -> bufferData num) |> Seq.mapi (fun num value -> writeFile ("file" + num.ToString() + ".dat") value) |> Async.Parallel try Async.RunSynchronously(async1, 100) |> ignore with | exc -> printfn "%s" exc.Message printfn "%d write operations completed successfully." !counter
Sample Output
The operation has timed out. 420 write operations completed successfully.
