Header menu logo FSharp.Core

Async Type

Holds static members for creating and manipulating asynchronous computations.

See also F# Language Guide - Async Workflows.

Table of contents

Starting Async Computations

Static members

Static member Description

Async.RunSynchronously(computation, ?timeout, ?cancellationToken)

Full Usage: Async.RunSynchronously(computation, ?timeout, ?cancellationToken)

Parameters:
    computation : Async<'T> - The computation to run.
    ?timeout : int - The amount of time in milliseconds to wait for the result of the computation before raising a TimeoutException. If no value is provided for timeout then a default of -1 is used to correspond to Timeout.Infinite.
    ?cancellationToken : CancellationToken - The cancellation token to be associated with the computation. If one is not supplied, the default cancellation token is used.

Returns: 'T The result of the computation.

Runs the asynchronous computation and await its result.

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 computation is started on the current thread if SynchronizationContext.Current is null, Thread.CurrentThread has Thread.IsThreadPoolThread of true, and no timeout is specified. Otherwise the computation is started by queueing a new work item in the thread pool, and the current thread is blocked awaiting the completion of the computation. The timeout parameter is given in milliseconds. A value of -1 is equivalent to Timeout.Infinite.

computation : Async<'T>

The computation to run.

?timeout : int

The amount of time in milliseconds to wait for the result of the computation before raising a TimeoutException. If no value is provided for timeout then a default of -1 is used to correspond to Timeout.Infinite.

?cancellationToken : CancellationToken

The cancellation token to be associated with the computation. If one is not supplied, the default cancellation token is used.

Returns: 'T

The result of the computation.

Example

 printfn "A"

 let result = async {
     printfn "B"
     do! Async.Sleep(1000)
     printfn "C"
     17
 } |> Async.RunSynchronously

 printfn "D"
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val result: Async<unit>
val async: AsyncBuilder
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.Sleep: dueTime: System.TimeSpan -> Async<unit>
static member Async.Sleep: millisecondsDueTime: int -> Async<unit>
static member Async.RunSynchronously: computation: Async<'T> * ?timeout: int * ?cancellationToken: System.Threading.CancellationToken -> 'T
Prints "A", "B" immediately, then "C", "D" in 1 second. result is set to 17.

Async.Start(computation, ?cancellationToken)

Full Usage: Async.Start(computation, ?cancellationToken)

Parameters:
    computation : Async<unit> - The computation to run asynchronously.
    ?cancellationToken : CancellationToken - The cancellation token to be associated with the computation. If one is not supplied, the default cancellation token is used.

Starts the asynchronous computation in the thread pool. Do not await its result.

If no cancellation token is provided then the default cancellation token is used.

computation : Async<unit>

The computation to run asynchronously.

?cancellationToken : CancellationToken

The cancellation token to be associated with the computation. If one is not supplied, the default cancellation token is used.

Example

 printfn "A"

 async {
     printfn "B"
     do! Async.Sleep(1000)
     printfn "C"
 } |> Async.Start

 printfn "D"
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val async: AsyncBuilder
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.Sleep: dueTime: System.TimeSpan -> Async<unit>
static member Async.Sleep: millisecondsDueTime: int -> Async<unit>
static member Async.Start: computation: Async<unit> * ?cancellationToken: System.Threading.CancellationToken -> unit
Prints "A", then "D", "B" quickly in any order, and then "C" in 1 second.

Async.StartAsTask(computation, ?taskCreationOptions, ?cancellationToken)

Full Usage: Async.StartAsTask(computation, ?taskCreationOptions, ?cancellationToken)

Parameters:
Returns: Task<'T> A Task that will be completed in the corresponding state once the computation terminates (produces the result, throws exception or gets canceled)

Executes a computation in the thread pool.

If no cancellation token is provided then the default cancellation token is used.

computation : Async<'T>
?taskCreationOptions : TaskCreationOptions
?cancellationToken : CancellationToken
Returns: Task<'T>

A Task that will be completed in the corresponding state once the computation terminates (produces the result, throws exception or gets canceled)

Example

 printfn "A"

 let t =
     async {
         printfn "B"
         do! Async.Sleep(1000)
         printfn "C"
     } |> Async.StartAsTask

 printfn "D"
 t.Wait()
 printfn "E"
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val t: System.Threading.Tasks.Task<unit>
val async: AsyncBuilder
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.Sleep: dueTime: System.TimeSpan -> Async<unit>
static member Async.Sleep: millisecondsDueTime: int -> Async<unit>
static member Async.StartAsTask: computation: Async<'T> * ?taskCreationOptions: System.Threading.Tasks.TaskCreationOptions * ?cancellationToken: System.Threading.CancellationToken -> System.Threading.Tasks.Task<'T>
System.Threading.Tasks.Task.Wait() : unit
System.Threading.Tasks.Task.Wait(timeout: System.TimeSpan) : bool
System.Threading.Tasks.Task.Wait(cancellationToken: System.Threading.CancellationToken) : unit
System.Threading.Tasks.Task.Wait(millisecondsTimeout: int) : bool
System.Threading.Tasks.Task.Wait(timeout: System.TimeSpan, cancellationToken: System.Threading.CancellationToken) : bool
System.Threading.Tasks.Task.Wait(millisecondsTimeout: int, cancellationToken: System.Threading.CancellationToken) : bool
Prints "A", then "D", "B" quickly in any order, then "C", "E" in 1 second.

Async.StartChildAsTask(computation, ?taskCreationOptions)

Full Usage: Async.StartChildAsTask(computation, ?taskCreationOptions)

Parameters:
Returns: Async<Task<'T>>

Creates an asynchronous computation which starts the given computation as a Task

computation : Async<'T>
?taskCreationOptions : TaskCreationOptions
Returns: Async<Task<'T>>

Async.StartImmediate(computation, ?cancellationToken)

Full Usage: Async.StartImmediate(computation, ?cancellationToken)

Parameters:
    computation : Async<unit> - The asynchronous computation to execute.
    ?cancellationToken : CancellationToken - The CancellationToken to associate with the computation. The default is used if this parameter is not provided.

Runs an asynchronous computation, starting immediately on the current operating system thread.

If no cancellation token is provided then the default cancellation token is used.

computation : Async<unit>

The asynchronous computation to execute.

?cancellationToken : CancellationToken

The CancellationToken to associate with the computation. The default is used if this parameter is not provided.

Example

 printfn "A"

 async {
     printfn "B"
     do! Async.Sleep(1000)
     printfn "C"
 } |> Async.StartImmediate

 printfn "D"
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val async: AsyncBuilder
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.Sleep: dueTime: System.TimeSpan -> Async<unit>
static member Async.Sleep: millisecondsDueTime: int -> Async<unit>
static member Async.StartImmediate: computation: Async<unit> * ?cancellationToken: System.Threading.CancellationToken -> unit
Prints "A", "B", "D" immediately, then "C" in 1 second

Async.StartImmediateAsTask(computation, ?cancellationToken)

Full Usage: Async.StartImmediateAsTask(computation, ?cancellationToken)

Parameters:
    computation : Async<'T> - The asynchronous computation to execute.
    ?cancellationToken : CancellationToken - The CancellationToken to associate with the computation. The default is used if this parameter is not provided.

Returns: Task<'T> A Task that will be completed in the corresponding state once the computation terminates (produces the result, throws exception or gets canceled)

Runs an asynchronous computation, starting immediately on the current operating system thread, but also returns the execution as Task

If no cancellation token is provided then the default cancellation token is used. You may prefer using this method if you want to achieve a similar behavior to async await in C# as async computation starts on the current thread with an ability to return a result.

computation : Async<'T>

The asynchronous computation to execute.

?cancellationToken : CancellationToken

The CancellationToken to associate with the computation. The default is used if this parameter is not provided.

Returns: Task<'T>

A Task that will be completed in the corresponding state once the computation terminates (produces the result, throws exception or gets canceled)

Example

 printfn "A"

 let t =
     async {
         printfn "B"
         do! Async.Sleep(1000)
         printfn "C"
     } |> Async.StartImmediateAsTask

 printfn "D"
 t.Wait()
 printfn "E"
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val t: System.Threading.Tasks.Task<unit>
val async: AsyncBuilder
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.Sleep: dueTime: System.TimeSpan -> Async<unit>
static member Async.Sleep: millisecondsDueTime: int -> Async<unit>
static member Async.StartImmediateAsTask: computation: Async<'T> * ?cancellationToken: System.Threading.CancellationToken -> System.Threading.Tasks.Task<'T>
System.Threading.Tasks.Task.Wait() : unit
System.Threading.Tasks.Task.Wait(timeout: System.TimeSpan) : bool
System.Threading.Tasks.Task.Wait(cancellationToken: System.Threading.CancellationToken) : unit
System.Threading.Tasks.Task.Wait(millisecondsTimeout: int) : bool
System.Threading.Tasks.Task.Wait(timeout: System.TimeSpan, cancellationToken: System.Threading.CancellationToken) : bool
System.Threading.Tasks.Task.Wait(millisecondsTimeout: int, cancellationToken: System.Threading.CancellationToken) : bool
Prints "A", "B", "D" immediately, then "C", "E" in 1 second.

Async.StartWithContinuations(computation, continuation, exceptionContinuation, cancellationContinuation, ?cancellationToken)

Full Usage: Async.StartWithContinuations(computation, continuation, exceptionContinuation, cancellationContinuation, ?cancellationToken)

Parameters:
    computation : Async<'T> - The asynchronous computation to execute.
    continuation : 'T -> unit - The function called on success.
    exceptionContinuation : exn -> unit - The function called on exception.
    cancellationContinuation : OperationCanceledException -> unit - The function called on cancellation.
    ?cancellationToken : CancellationToken - The CancellationToken to associate with the computation. The default is used if this parameter is not provided.

Runs an asynchronous computation, starting immediately on the current operating system thread. Call one of the three continuations when the operation completes.

If no cancellation token is provided then the default cancellation token is used.

computation : Async<'T>

The asynchronous computation to execute.

continuation : 'T -> unit

The function called on success.

exceptionContinuation : exn -> unit

The function called on exception.

cancellationContinuation : OperationCanceledException -> unit

The function called on cancellation.

?cancellationToken : CancellationToken

The CancellationToken to associate with the computation. The default is used if this parameter is not provided.

Composing Async Computations

Static members

Static member Description

Async.Choice(computations)

Full Usage: Async.Choice(computations)

Parameters:
    computations : Async<'T option> seq - A sequence of computations to be parallelized.

Returns: Async<'T option> A computation that returns the first succeeding computation.

Creates an asynchronous computation that executes all given asynchronous computations in parallel, returning the result of the first succeeding computation (one whose result is 'Some x'). If all child computations complete with None, the parent computation also returns None.

If any child computation raises an exception, then the overall computation will trigger an exception, and cancel the others. The overall computation will respond to cancellation while executing the child computations. If cancelled, the computation will cancel any remaining child computations but will still wait for the other child computations to complete.

computations : Async<'T option> seq

A sequence of computations to be parallelized.

Returns: Async<'T option>

A computation that returns the first succeeding computation.

Example

 printfn "Starting"
 let primes = [ 2; 3; 5; 7 ]
 let computations =
     [ for i in primes do
         async {
             do! Async.Sleep(System.Random().Next(1000, 2000))
             return if i % 2 > 0 then Some(i) else None
         }
     ]

 computations
 |> Async.Choice
 |> Async.RunSynchronously
 |> function
     | Some (i) -> printfn $"{i}"
     | None -> printfn "No Result"
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val primes: int list
val computations: Async<int option> list
val i: int
val async: AsyncBuilder
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.Sleep: dueTime: System.TimeSpan -> Async<unit>
static member Async.Sleep: millisecondsDueTime: int -> Async<unit>
namespace System
Multiple items
type Random = new: unit -> unit + 1 overload member GetItems<'T> : choices: ReadOnlySpan<'T> * length: int -> 'T array + 2 overloads member Next: unit -> int + 2 overloads member NextBytes: buffer: byte array -> unit + 1 overload member NextDouble: unit -> float member NextInt64: unit -> int64 + 2 overloads member NextSingle: unit -> float32 member Shuffle<'T> : values: Span<'T> -> unit + 1 overload static member Shared: Random

--------------------
System.Random() : System.Random
System.Random(Seed: int) : System.Random
union case Option.Some: Value: 'T -> Option<'T>
union case Option.None: Option<'T>
static member Async.Choice: computations: Async<'T option> seq -> Async<'T option>
static member Async.RunSynchronously: computation: Async<'T> * ?timeout: int * ?cancellationToken: System.Threading.CancellationToken -> 'T
Prints one randomly selected odd number in 1-2 seconds. If the list is changed to all even numbers, it will instead print "No Result".

Example

 let primes = [ 2; 3; 5; 7 ]
 let computations =
     [ for i in primes do
         async {
             do! Async.Sleep(System.Random().Next(1000, 2000))

             return
                 if i % 2 > 0 then
                     Some(i)
                 else
                     failwith $"Even numbers not supported: {i}"
         }
     ]

 computations
 |> Async.Choice
 |> Async.RunSynchronously
 |> function
     | Some (i) -> printfn $"{i}"
     | None -> printfn "No Result"
val primes: int list
val computations: Async<int option> list
val i: int
val async: AsyncBuilder
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.Sleep: dueTime: System.TimeSpan -> Async<unit>
static member Async.Sleep: millisecondsDueTime: int -> Async<unit>
namespace System
Multiple items
type Random = new: unit -> unit + 1 overload member GetItems<'T> : choices: ReadOnlySpan<'T> * length: int -> 'T array + 2 overloads member Next: unit -> int + 2 overloads member NextBytes: buffer: byte array -> unit + 1 overload member NextDouble: unit -> float member NextInt64: unit -> int64 + 2 overloads member NextSingle: unit -> float32 member Shuffle<'T> : values: Span<'T> -> unit + 1 overload static member Shared: Random

--------------------
System.Random() : System.Random
System.Random(Seed: int) : System.Random
union case Option.Some: Value: 'T -> Option<'T>
val failwith: message: string -> 'T
static member Async.Choice: computations: Async<'T option> seq -> Async<'T option>
static member Async.RunSynchronously: computation: Async<'T> * ?timeout: int * ?cancellationToken: System.Threading.CancellationToken -> 'T
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
union case Option.None: Option<'T>
Will sometimes print one randomly selected odd number, sometimes throw System.Exception("Even numbers not supported: 2").

Async.FromContinuations(callback)

Full Usage: Async.FromContinuations(callback)

Parameters:
Returns: Async<'T> An asynchronous computation that provides the callback with the current continuations.

Creates an asynchronous computation that captures the current success, exception and cancellation continuations. The callback must eventually call exactly one of the given continuations.

callback : ('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit

The function that accepts the current success, exception, and cancellation continuations.

Returns: Async<'T>

An asynchronous computation that provides the callback with the current continuations.

Example

 let someRiskyBusiness() =
 match DateTime.Today with
 | dt when dt.DayOfWeek = DayOfWeek.Monday -> failwith "Not compatible with Mondays"
 | dt -> dt
 
 let computation =
     (fun (successCont, exceptionCont, cancellationCont) ->
         try
             someRiskyBusiness () |> successCont
         with
         | :? OperationCanceledException as oce -> cancellationCont oce
         | e -> exceptionCont e)
     |> Async.FromContinuations

 Async.StartWithContinuations(
     computation,
     (fun result -> printfn $"Result: {result}"),
     (fun e -> printfn $"Exception: {e}"),
     (fun oce -> printfn $"Cancelled: {oce}")
  )
val someRiskyBusiness: unit -> 'a
val dt: obj
val failwith: message: string -> 'T
val computation: Async<obj>
val successCont: (obj -> unit)
val exceptionCont: (exn -> unit)
val cancellationCont: (System.OperationCanceledException -> unit)
val oce: System.OperationCanceledException
val oce: exn
val e: exn
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.FromContinuations: callback: (('T -> unit) * (exn -> unit) * (System.OperationCanceledException -> unit) -> unit) -> Async<'T>
static member Async.StartWithContinuations: computation: Async<'T> * continuation: ('T -> unit) * exceptionContinuation: (exn -> unit) * cancellationContinuation: (System.OperationCanceledException -> unit) * ?cancellationToken: System.Threading.CancellationToken -> unit
val result: obj
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
This anonymous function will call someRiskyBusiness() and properly use the provided continuations defined to report the outcome.

Async.Ignore(computation)

Full Usage: Async.Ignore(computation)

Parameters:
    computation : Async<'T> - The input computation.

Returns: Async<unit> A computation that is equivalent to the input computation, but disregards the result.

Creates an asynchronous computation that runs the given computation and ignores its result.

computation : Async<'T>

The input computation.

Returns: Async<unit>

A computation that is equivalent to the input computation, but disregards the result.

Example

 let readFile filename numBytes =
     async {
         use file = System.IO.File.OpenRead(filename)
         printfn "Reading from file %s." filename
         // Throw away the data being read.
         do! file.AsyncRead(numBytes) |> Async.Ignore
     }
 readFile "example.txt" 42 |> Async.Start
val readFile: filename: string -> numBytes: int -> Async<unit>
val filename: string
val numBytes: int
val async: AsyncBuilder
val file: System.IO.FileStream
namespace System
namespace System.IO
type File = static member AppendAllBytes: path: string * bytes: byte array -> unit + 1 overload static member AppendAllBytesAsync: path: string * bytes: byte array * ?cancellationToken: CancellationToken -> Task + 1 overload static member AppendAllLines: path: string * contents: IEnumerable<string> -> unit + 1 overload static member AppendAllLinesAsync: path: string * contents: IEnumerable<string> * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 1 overload static member AppendAllText: path: string * contents: string -> unit + 3 overloads static member AppendAllTextAsync: path: string * contents: string * encoding: Encoding * ?cancellationToken: CancellationToken -> Task + 3 overloads static member AppendText: path: string -> StreamWriter static member Copy: sourceFileName: string * destFileName: string -> unit + 1 overload static member Create: path: string -> FileStream + 2 overloads static member CreateSymbolicLink: path: string * pathToTarget: string -> FileSystemInfo ...
System.IO.File.OpenRead(path: string) : System.IO.FileStream
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
member System.IO.Stream.AsyncRead: count: int -> Async<byte array>
member System.IO.Stream.AsyncRead: buffer: byte array * ?offset: int * ?count: int -> Async<int>
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.Ignore: computation: Async<'T> -> Async<unit>
static member Async.Start: computation: Async<unit> * ?cancellationToken: System.Threading.CancellationToken -> unit
Reads bytes from a given file asynchronously and then ignores the result, allowing the do! to be used with functions that return an unwanted value.

Async.Parallel(computations, ?maxDegreeOfParallelism)

Full Usage: Async.Parallel(computations, ?maxDegreeOfParallelism)

Parameters:
    computations : Async<'T> seq - A sequence of distinct computations to be parallelized.
    ?maxDegreeOfParallelism : int - The maximum degree of parallelism in the parallel execution.

Returns: Async<'T array> A computation that returns an array of values from the sequence of input computations.

Creates an asynchronous computation that executes all the given asynchronous computations, initially queueing each as work items and using a fork/join pattern.

If all child computations succeed, an array of results is passed to the success continuation. If any child computation raises an exception, then the overall computation will trigger an exception, and cancel the others. The overall computation will respond to cancellation while executing the child computations. If cancelled, the computation will cancel any remaining child computations but will still wait for the other child computations to complete.

computations : Async<'T> seq

A sequence of distinct computations to be parallelized.

?maxDegreeOfParallelism : int

The maximum degree of parallelism in the parallel execution.

Returns: Async<'T array>

A computation that returns an array of values from the sequence of input computations.

Example

 let primes = [ 2; 3; 5; 7; 10; 11 ]
 let computations =
     [ for i in primes do
         async {
             do! Async.Sleep(System.Random().Next(1000, 2000))

             return
                 if i % 2 > 0 then
                     printfn $"{i}"
                     true
                 else
                     false
         } ]

 let t =
     Async.Parallel(computations, maxDegreeOfParallelism=3)
     |> Async.StartAsTask

 t.Wait()
 printfn $"%A{t.Result}"
val primes: int list
val computations: Async<bool> list
val i: int
val async: AsyncBuilder
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.Sleep: dueTime: System.TimeSpan -> Async<unit>
static member Async.Sleep: millisecondsDueTime: int -> Async<unit>
namespace System
Multiple items
type Random = new: unit -> unit + 1 overload member GetItems<'T> : choices: ReadOnlySpan<'T> * length: int -> 'T array + 2 overloads member Next: unit -> int + 2 overloads member NextBytes: buffer: byte array -> unit + 1 overload member NextDouble: unit -> float member NextInt64: unit -> int64 + 2 overloads member NextSingle: unit -> float32 member Shuffle<'T> : values: Span<'T> -> unit + 1 overload static member Shared: Random

--------------------
System.Random() : System.Random
System.Random(Seed: int) : System.Random
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val t: System.Threading.Tasks.Task<bool array>
static member Async.Parallel: computations: Async<'T> seq -> Async<'T array>
static member Async.Parallel: computations: Async<'T> seq * ?maxDegreeOfParallelism: int -> Async<'T array>
static member Async.StartAsTask: computation: Async<'T> * ?taskCreationOptions: System.Threading.Tasks.TaskCreationOptions * ?cancellationToken: System.Threading.CancellationToken -> System.Threading.Tasks.Task<'T>
System.Threading.Tasks.Task.Wait() : unit
System.Threading.Tasks.Task.Wait(timeout: System.TimeSpan) : bool
System.Threading.Tasks.Task.Wait(cancellationToken: System.Threading.CancellationToken) : unit
System.Threading.Tasks.Task.Wait(millisecondsTimeout: int) : bool
System.Threading.Tasks.Task.Wait(timeout: System.TimeSpan, cancellationToken: System.Threading.CancellationToken) : bool
System.Threading.Tasks.Task.Wait(millisecondsTimeout: int, cancellationToken: System.Threading.CancellationToken) : bool
property System.Threading.Tasks.Task.Result: bool array with get
This will print "3", "5" (in any order) in 1-2 seconds, and then "7", "11" (in any order) in 1-2 more seconds and then [| false; true; true; true; false; true |].

Async.Parallel(computations)

Full Usage: Async.Parallel(computations)

Parameters:
    computations : Async<'T> seq - A sequence of distinct computations to be parallelized.

Returns: Async<'T array> A computation that returns an array of values from the sequence of input computations.

Creates an asynchronous computation that executes all the given asynchronous computations, initially queueing each as work items and using a fork/join pattern.

If all child computations succeed, an array of results is passed to the success continuation. If any child computation raises an exception, then the overall computation will trigger an exception, and cancel the others. The overall computation will respond to cancellation while executing the child computations. If cancelled, the computation will cancel any remaining child computations but will still wait for the other child computations to complete.

computations : Async<'T> seq

A sequence of distinct computations to be parallelized.

Returns: Async<'T array>

A computation that returns an array of values from the sequence of input computations.

Example

 let primes = [ 2; 3; 5; 7; 10; 11 ]
 let t =
     [ for i in primes do
         async {
             do! Async.Sleep(System.Random().Next(1000, 2000))

             if i % 2 > 0 then
                 printfn $"{i}"
                 return true
             else
                 return false
         }
     ]
     |> Async.Parallel
     |> Async.StartAsTask

 t.Wait()
 printfn $"%A{t.Result}"
val primes: int list
val t: System.Threading.Tasks.Task<bool array>
val i: int
val async: AsyncBuilder
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.Sleep: dueTime: System.TimeSpan -> Async<unit>
static member Async.Sleep: millisecondsDueTime: int -> Async<unit>
namespace System
Multiple items
type Random = new: unit -> unit + 1 overload member GetItems<'T> : choices: ReadOnlySpan<'T> * length: int -> 'T array + 2 overloads member Next: unit -> int + 2 overloads member NextBytes: buffer: byte array -> unit + 1 overload member NextDouble: unit -> float member NextInt64: unit -> int64 + 2 overloads member NextSingle: unit -> float32 member Shuffle<'T> : values: Span<'T> -> unit + 1 overload static member Shared: Random

--------------------
System.Random() : System.Random
System.Random(Seed: int) : System.Random
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
static member Async.Parallel: computations: Async<'T> seq -> Async<'T array>
static member Async.Parallel: computations: Async<'T> seq * ?maxDegreeOfParallelism: int -> Async<'T array>
static member Async.StartAsTask: computation: Async<'T> * ?taskCreationOptions: System.Threading.Tasks.TaskCreationOptions * ?cancellationToken: System.Threading.CancellationToken -> System.Threading.Tasks.Task<'T>
System.Threading.Tasks.Task.Wait() : unit
System.Threading.Tasks.Task.Wait(timeout: System.TimeSpan) : bool
System.Threading.Tasks.Task.Wait(cancellationToken: System.Threading.CancellationToken) : unit
System.Threading.Tasks.Task.Wait(millisecondsTimeout: int) : bool
System.Threading.Tasks.Task.Wait(timeout: System.TimeSpan, cancellationToken: System.Threading.CancellationToken) : bool
System.Threading.Tasks.Task.Wait(millisecondsTimeout: int, cancellationToken: System.Threading.CancellationToken) : bool
property System.Threading.Tasks.Task.Result: bool array with get
This will print "3", "5", "7", "11" (in any order) in 1-2 seconds and then [| false; true; true; true; false; true |].

Async.Sequential(computations)

Full Usage: Async.Sequential(computations)

Parameters:
    computations : Async<'T> seq - A sequence of distinct computations to be run in sequence.

Returns: Async<'T array> A computation that returns an array of values from the sequence of input computations.

Creates an asynchronous computation that executes all the given asynchronous computations sequentially.

If all child computations succeed, an array of results is passed to the success continuation. If any child computation raises an exception, then the overall computation will trigger an exception, and cancel the others. The overall computation will respond to cancellation while executing the child computations. If cancelled, the computation will cancel any remaining child computations but will still wait for the other child computations to complete.

computations : Async<'T> seq

A sequence of distinct computations to be run in sequence.

Returns: Async<'T array>

A computation that returns an array of values from the sequence of input computations.

Example

 let primes = [ 2; 3; 5; 7; 10; 11 ]
 let computations =
     [ for i in primes do
             async {
                 do! Async.Sleep(System.Random().Next(1000, 2000))

                 if i % 2 > 0 then
                     printfn $"{i}"
                     return true
                 else
                     return false
             }
    ]

 let t =
     Async.Sequential(computations)
     |> Async.StartAsTask

 t.Wait()
 printfn $"%A{t.Result}"
val primes: int list
val computations: Async<bool> list
val i: int
val async: AsyncBuilder
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.Sleep: dueTime: System.TimeSpan -> Async<unit>
static member Async.Sleep: millisecondsDueTime: int -> Async<unit>
namespace System
Multiple items
type Random = new: unit -> unit + 1 overload member GetItems<'T> : choices: ReadOnlySpan<'T> * length: int -> 'T array + 2 overloads member Next: unit -> int + 2 overloads member NextBytes: buffer: byte array -> unit + 1 overload member NextDouble: unit -> float member NextInt64: unit -> int64 + 2 overloads member NextSingle: unit -> float32 member Shuffle<'T> : values: Span<'T> -> unit + 1 overload static member Shared: Random

--------------------
System.Random() : System.Random
System.Random(Seed: int) : System.Random
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val t: System.Threading.Tasks.Task<bool array>
static member Async.Sequential: computations: Async<'T> seq -> Async<'T array>
static member Async.StartAsTask: computation: Async<'T> * ?taskCreationOptions: System.Threading.Tasks.TaskCreationOptions * ?cancellationToken: System.Threading.CancellationToken -> System.Threading.Tasks.Task<'T>
System.Threading.Tasks.Task.Wait() : unit
System.Threading.Tasks.Task.Wait(timeout: System.TimeSpan) : bool
System.Threading.Tasks.Task.Wait(cancellationToken: System.Threading.CancellationToken) : unit
System.Threading.Tasks.Task.Wait(millisecondsTimeout: int) : bool
System.Threading.Tasks.Task.Wait(timeout: System.TimeSpan, cancellationToken: System.Threading.CancellationToken) : bool
System.Threading.Tasks.Task.Wait(millisecondsTimeout: int, cancellationToken: System.Threading.CancellationToken) : bool
property System.Threading.Tasks.Task.Result: bool array with get
This will print "3", "5", "7", "11" with ~1-2 seconds between them except for pauses where even numbers would be and then prints [| false; true; true; true; false; true |].

Awaiting Results

Static members

Static member Description

Async.AwaitEvent(event, ?cancelAction)

Full Usage: Async.AwaitEvent(event, ?cancelAction)

Parameters:
    event : IEvent<'Del, 'T> - The event to handle once.
    ?cancelAction : unit -> unit - An optional function to execute instead of cancelling when a cancellation is issued.

Returns: Async<'T> An asynchronous computation that waits for the event to be invoked.

Creates an asynchronous computation that waits for a single invocation of a CLI event by adding a handler to the event. Once the computation completes or is cancelled, the handler is removed from the event.

The computation will respond to cancellation while waiting for the event. If a cancellation occurs, and cancelAction is specified, then it is executed, and the computation continues to wait for the event. If cancelAction is not specified, then cancellation causes the computation to cancel immediately.

event : IEvent<'Del, 'T>

The event to handle once.

?cancelAction : unit -> unit

An optional function to execute instead of cancelling when a cancellation is issued.

Returns: Async<'T>

An asynchronous computation that waits for the event to be invoked.

Async.AwaitIAsyncResult(iar, ?millisecondsTimeout)

Full Usage: Async.AwaitIAsyncResult(iar, ?millisecondsTimeout)

Parameters:
    iar : IAsyncResult - The IAsyncResult to wait on.
    ?millisecondsTimeout : int - The timeout value in milliseconds. If one is not provided then the default value of -1 corresponding to Timeout.Infinite.

Returns: Async<bool> An asynchronous computation that waits on the given IAsyncResult.

Creates an asynchronous computation that will wait on the IAsyncResult.

The computation returns true if the handle indicated a result within the given timeout.

iar : IAsyncResult

The IAsyncResult to wait on.

?millisecondsTimeout : int

The timeout value in milliseconds. If one is not provided then the default value of -1 corresponding to Timeout.Infinite.

Returns: Async<bool>

An asynchronous computation that waits on the given IAsyncResult.

Async.AwaitTask(task)

Full Usage: Async.AwaitTask(task)

Parameters:
    task : Task - The task to await.

Returns: Async<unit>

Return an asynchronous computation that will wait for the given task to complete and return its result.

If an exception occurs in the asynchronous computation then an exception is re-raised by this function. If the task is cancelled then Tasks.TaskCanceledException is raised. Note that the task may be governed by a different cancellation token to the overall async computation where the AwaitTask occurs. In practice you should normally start the task with the cancellation token returned by let! ct = Async.CancellationToken, and catch any Tasks.TaskCanceledException at the point where the overall async is started.

task : Task

The task to await.

Returns: Async<unit>

Async.AwaitTask(task)

Full Usage: Async.AwaitTask(task)

Parameters:
    task : Task<'T> - The task to await.

Returns: Async<'T>

Return an asynchronous computation that will wait for the given task to complete and return its result.

If an exception occurs in the asynchronous computation then an exception is re-raised by this function. If the task is cancelled then Tasks.TaskCanceledException is raised. Note that the task may be governed by a different cancellation token to the overall async computation where the AwaitTask occurs. In practice you should normally start the task with the cancellation token returned by let! ct = Async.CancellationToken, and catch any Tasks.TaskCanceledException at the point where the overall async is started.

task : Task<'T>

The task to await.

Returns: Async<'T>

Async.AwaitWaitHandle(waitHandle, ?millisecondsTimeout)

Full Usage: Async.AwaitWaitHandle(waitHandle, ?millisecondsTimeout)

Parameters:
    waitHandle : WaitHandle - The WaitHandle that can be signalled.
    ?millisecondsTimeout : int - The timeout value in milliseconds. If one is not provided then the default value of -1 corresponding to Timeout.Infinite.

Returns: Async<bool> An asynchronous computation that waits on the given WaitHandle.

Creates an asynchronous computation that will wait on the given WaitHandle.

The computation returns true if the handle indicated a result within the given timeout.

waitHandle : WaitHandle

The WaitHandle that can be signalled.

?millisecondsTimeout : int

The timeout value in milliseconds. If one is not provided then the default value of -1 corresponding to Timeout.Infinite.

Returns: Async<bool>

An asynchronous computation that waits on the given WaitHandle.

Async.Sleep(dueTime)

Full Usage: Async.Sleep(dueTime)

Parameters:
    dueTime : TimeSpan - The amount of time to sleep.

Returns: Async<unit> An asynchronous computation that will sleep for the given time.

Creates an asynchronous computation that will sleep for the given time. This is scheduled using a System.Threading.Timer object. The operation will not block operating system threads for the duration of the wait.

dueTime : TimeSpan

The amount of time to sleep.

Returns: Async<unit>

An asynchronous computation that will sleep for the given time.

ArgumentOutOfRangeException Thrown when the due time is negative.
Example

 async {
     printfn "A"
     do! Async.Sleep(TimeSpan(0, 0, 1))
     printfn "B"
 } |> Async.Start
 printfn "C"
val async: AsyncBuilder
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.Sleep: dueTime: System.TimeSpan -> Async<unit>
static member Async.Sleep: millisecondsDueTime: int -> Async<unit>
static member Async.Start: computation: Async<unit> * ?cancellationToken: System.Threading.CancellationToken -> unit
Prints "C", then "A" quickly, and then "B" 1 second later.

Async.Sleep(millisecondsDueTime)

Full Usage: Async.Sleep(millisecondsDueTime)

Parameters:
    millisecondsDueTime : int - The number of milliseconds to sleep.

Returns: Async<unit> An asynchronous computation that will sleep for the given time.

Creates an asynchronous computation that will sleep for the given time. This is scheduled using a System.Threading.Timer object. The operation will not block operating system threads for the duration of the wait.

millisecondsDueTime : int

The number of milliseconds to sleep.

Returns: Async<unit>

An asynchronous computation that will sleep for the given time.

ArgumentOutOfRangeException Thrown when the due time is negative and not infinite.
Example

 async {
     printfn "A"
     do! Async.Sleep(1000)
     printfn "B"
 } |> Async.Start

 printfn "C"
val async: AsyncBuilder
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.Sleep: dueTime: System.TimeSpan -> Async<unit>
static member Async.Sleep: millisecondsDueTime: int -> Async<unit>
static member Async.Start: computation: Async<unit> * ?cancellationToken: System.Threading.CancellationToken -> unit
Prints "C" and "A" quickly in any order, and then "B" 1 second later

Cancellation and Exceptions

Static members

Static member Description

Async.CancelDefaultToken()

Full Usage: Async.CancelDefaultToken()

Raises the cancellation condition for the most recent set of asynchronous computations started without any specific CancellationToken. Replaces the global CancellationTokenSource with a new global token source for any asynchronous computations created after this point without any specific CancellationToken.

Example

 let primes = [ 2; 3; 5; 7; 11 ]

 let computations =
     [ for i in primes do
             async {
                 do! Async.Sleep(i * 1000)
                 printfn $"{i}"
             }
     ]

 try
     let t =
         Async.Parallel(computations, 3) |> Async.StartAsTask

     Thread.Sleep(6000)
     Async.CancelDefaultToken()
     printfn $"Tasks Finished: %A{t.Result}"
 with
 | :? System.AggregateException as ae -> printfn $"Tasks Not Finished: {ae.Message}"
val primes: int list
val computations: Async<unit> list
val i: int
val async: AsyncBuilder
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.Sleep: dueTime: System.TimeSpan -> Async<unit>
static member Async.Sleep: millisecondsDueTime: int -> Async<unit>
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val t: System.Threading.Tasks.Task<unit array>
static member Async.Parallel: computations: Async<'T> seq -> Async<'T array>
static member Async.Parallel: computations: Async<'T> seq * ?maxDegreeOfParallelism: int -> Async<'T array>
static member Async.StartAsTask: computation: Async<'T> * ?taskCreationOptions: System.Threading.Tasks.TaskCreationOptions * ?cancellationToken: System.Threading.CancellationToken -> System.Threading.Tasks.Task<'T>
static member Async.CancelDefaultToken: unit -> unit
property System.Threading.Tasks.Task.Result: unit array with get
namespace System
Multiple items
type AggregateException = inherit exn new: unit -> unit + 6 overloads member Flatten: unit -> AggregateException member GetBaseException: unit -> exn member GetObjectData: info: SerializationInfo * context: StreamingContext -> unit member Handle: predicate: Func<exn,bool> -> unit member ToString: unit -> string member InnerExceptions: ReadOnlyCollection<exn> member Message: string

--------------------
System.AggregateException() : System.AggregateException
System.AggregateException(innerExceptions: System.Collections.Generic.IEnumerable<exn>) : System.AggregateException
System.AggregateException([<System.ParamArray>] innerExceptions: exn array) : System.AggregateException
System.AggregateException(message: string) : System.AggregateException
System.AggregateException(message: string, innerExceptions: System.Collections.Generic.IEnumerable<exn>) : System.AggregateException
System.AggregateException(message: string, innerException: exn) : System.AggregateException
System.AggregateException(message: string, [<System.ParamArray>] innerExceptions: exn array) : System.AggregateException
val ae: System.AggregateException
property System.AggregateException.Message: string with get
This will print "2" 2 seconds from start, "3" 3 seconds from start, "5" 5 seconds from start, cease computation and then print "Tasks Not Finished: One or more errors occurred. (A task was canceled.)".

Async.CancellationToken

Full Usage: Async.CancellationToken

Returns: Async<CancellationToken> An asynchronous computation capable of retrieving the CancellationToken from a computation expression.

Creates an asynchronous computation that returns the CancellationToken governing the execution of the computation.

In async { let! token = Async.CancellationToken ...} token can be used to initiate other asynchronous operations that will cancel cooperatively with this workflow.

Returns: Async<CancellationToken>

An asynchronous computation capable of retrieving the CancellationToken from a computation expression.

Async.Catch(computation)

Full Usage: Async.Catch(computation)

Parameters:
    computation : Async<'T> - The input computation that returns the type T.

Returns: Async<Choice<'T, exn>> A computation that returns a choice of type T or exception.

Creates an asynchronous computation that executes computation. If this computation completes successfully then return Choice1Of2 with the returned value. If this computation raises an exception before it completes then return Choice2Of2 with the raised exception.

computation : Async<'T>

The input computation that returns the type T.

Returns: Async<Choice<'T, exn>>

A computation that returns a choice of type T or exception.

Example

 let someRiskyBusiness() =
 match DateTime.Today with
 | dt when dt.DayOfWeek = DayOfWeek.Monday -> failwith "Not compatible with Mondays"
 | dt -> dt
 
 async { return someRiskyBusiness() }
 |> Async.Catch
 |> Async.RunSynchronously
 |> function
     | Choice1Of2 result -> printfn $"Result: {result}"
     | Choice2Of2 e -> printfn $"Exception: {e}"
val someRiskyBusiness: unit -> 'a
val dt: obj
val failwith: message: string -> 'T
val async: AsyncBuilder
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.Catch: computation: Async<'T> -> Async<Choice<'T,exn>>
static member Async.RunSynchronously: computation: Async<'T> * ?timeout: int * ?cancellationToken: System.Threading.CancellationToken -> 'T
union case Choice.Choice1Of2: 'T1 -> Choice<'T1,'T2>
val result: obj
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
union case Choice.Choice2Of2: 'T2 -> Choice<'T1,'T2>
val e: exn
Prints the returned value of someRiskyBusiness() or the exception if there is one.

Async.DefaultCancellationToken

Full Usage: Async.DefaultCancellationToken

Returns: CancellationToken The default CancellationToken.

Gets the default cancellation token for executing asynchronous computations.

Returns: CancellationToken

The default CancellationToken.

Example

 Async.DefaultCancellationToken.Register(fun () -> printfn "Computation Cancelled") |> ignore
 let primes = [ 2; 3; 5; 7; 11 ]

 for i in primes do
     async {
         do! Async.Sleep(i * 1000)
         printfn $"{i}"
     }
     |> Async.Start

 Thread.Sleep(6000)
 Async.CancelDefaultToken()
 printfn "Tasks Finished"
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
property Async.DefaultCancellationToken: System.Threading.CancellationToken with get
System.Threading.CancellationToken.Register(callback: System.Action) : System.Threading.CancellationTokenRegistration
System.Threading.CancellationToken.Register(callback: System.Action<obj>, state: obj) : System.Threading.CancellationTokenRegistration
System.Threading.CancellationToken.Register(callback: System.Action<obj,System.Threading.CancellationToken>, state: obj) : System.Threading.CancellationTokenRegistration
System.Threading.CancellationToken.Register(callback: System.Action, useSynchronizationContext: bool) : System.Threading.CancellationTokenRegistration
System.Threading.CancellationToken.Register(callback: System.Action<obj>, state: obj, useSynchronizationContext: bool) : System.Threading.CancellationTokenRegistration
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val ignore: value: 'T -> unit
val primes: int list
val i: int
val async: AsyncBuilder
static member Async.Sleep: dueTime: System.TimeSpan -> Async<unit>
static member Async.Sleep: millisecondsDueTime: int -> Async<unit>
static member Async.Start: computation: Async<unit> * ?cancellationToken: System.Threading.CancellationToken -> unit
static member Async.CancelDefaultToken: unit -> unit
This will print "2" 2 seconds from start, "3" 3 seconds from start, "5" 5 seconds from start, cease computation and then print "Computation Cancelled", followed by "Tasks Finished".

Async.OnCancel(interruption)

Full Usage: Async.OnCancel(interruption)

Parameters:
    interruption : unit -> unit - The function that is executed on the thread performing the cancellation.

Returns: Async<IDisposable> An asynchronous computation that triggers the interruption if it is cancelled before being disposed.

Generates a scoped, cooperative cancellation handler for use within an asynchronous workflow.

For example, async { use! holder = Async.OnCancel interruption ... } generates an asynchronous computation where, if a cancellation happens any time during the execution of the asynchronous computation in the scope of holder, then action interruption is executed on the thread that is performing the cancellation. This can be used to arrange for a computation to be asynchronously notified that a cancellation has occurred, e.g. by setting a flag, or deregistering a pending I/O action.

interruption : unit -> unit

The function that is executed on the thread performing the cancellation.

Returns: Async<IDisposable>

An asynchronous computation that triggers the interruption if it is cancelled before being disposed.

Example

 let primes = [ 2; 3; 5; 7; 11 ]
 for i in primes do
     async {
         use! holder = Async.OnCancel(fun () -> printfn $"Computation Cancelled: {i}")
         do! Async.Sleep(i * 1000)
         printfn $"{i}"
     }
     |> Async.Start

 Thread.Sleep(6000)
 Async.CancelDefaultToken()
 printfn "Tasks Finished"
val primes: int list
val i: int
val async: AsyncBuilder
val holder: System.IDisposable
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.OnCancel: interruption: (unit -> unit) -> Async<System.IDisposable>
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
static member Async.Sleep: dueTime: System.TimeSpan -> Async<unit>
static member Async.Sleep: millisecondsDueTime: int -> Async<unit>
static member Async.Start: computation: Async<unit> * ?cancellationToken: System.Threading.CancellationToken -> unit
static member Async.CancelDefaultToken: unit -> unit
This will print "2" 2 seconds from start, "3" 3 seconds from start, "5" 5 seconds from start, cease computation and then print "Computation Cancelled: 7", "Computation Cancelled: 11" and "Tasks Finished" in any order.

Async.StartChild(computation, ?millisecondsTimeout)

Full Usage: Async.StartChild(computation, ?millisecondsTimeout)

Parameters:
    computation : Async<'T> - The child computation.
    ?millisecondsTimeout : int - The timeout value in milliseconds. If one is not provided then the default value of -1 corresponding to Timeout.Infinite.

Returns: Async<Async<'T>> A new computation that waits for the input computation to finish.

Starts a child computation within an asynchronous workflow. This allows multiple asynchronous computations to be executed simultaneously.

This method should normally be used as the immediate right-hand-side of a let! binding in an F# asynchronous workflow, that is,

     async { ...
            let! completor1 = childComputation1 |> Async.StartChild  
            let! completor2 = childComputation2 |> Async.StartChild  
            ... 
            let! result1 = completor1 
            let! result2 = completor2 
            ... }
val async: AsyncBuilder
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.StartChild: computation: Async<'T> * ?millisecondsTimeout: int -> Async<Async<'T>>
When used in this way, each use of StartChild starts an instance of childComputation and returns a completor object representing a computation to wait for the completion of the operation. When executed, the completor awaits the completion of childComputation.

computation : Async<'T>

The child computation.

?millisecondsTimeout : int

The timeout value in milliseconds. If one is not provided then the default value of -1 corresponding to Timeout.Infinite.

Returns: Async<Async<'T>>

A new computation that waits for the input computation to finish.

Example

 let computeWithTimeout timeout =
     async {
         let! completor1 =
             Async.StartChild(
                 (async {
                     do! Async.Sleep(1000)
                     return 1
                  }),
                 millisecondsTimeout = timeout)

         let! completor2 =
             Async.StartChild(
                 (async {
                     do! Async.Sleep(2000)
                     return 2
                  }),
                 millisecondsTimeout = timeout)

         let! v1 = completor1
         let! v2 = completor2
         printfn $"Result: {v1 + v2}"
     } |> Async.RunSynchronously
val computeWithTimeout: timeout: int -> unit
val timeout: int
val async: AsyncBuilder
val completor1: Async<int>
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.StartChild: computation: Async<'T> * ?millisecondsTimeout: int -> Async<Async<'T>>
static member Async.Sleep: dueTime: System.TimeSpan -> Async<unit>
static member Async.Sleep: millisecondsDueTime: int -> Async<unit>
val completor2: Async<int>
val v1: int
val v2: int
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
static member Async.RunSynchronously: computation: Async<'T> * ?timeout: int * ?cancellationToken: System.Threading.CancellationToken -> 'T
Will throw a System.TimeoutException if called with a timeout less than 2000, otherwise will print "Result: 3".

Async.TryCancelled(computation, compensation)

Full Usage: Async.TryCancelled(computation, compensation)

Parameters:
Returns: Async<'T> An asynchronous computation that runs the compensation if the input computation is cancelled.

Creates an asynchronous computation that executes computation. If this computation is cancelled before it completes then the computation generated by running compensation is executed.

computation : Async<'T>

The input asynchronous computation.

compensation : OperationCanceledException -> unit

The function to be run if the computation is cancelled.

Returns: Async<'T>

An asynchronous computation that runs the compensation if the input computation is cancelled.

Example

 let primes = [ 2; 3; 5; 7; 11 ]
 for i in primes do
     Async.TryCancelled(
         async {
             do! Async.Sleep(i * 1000)
             printfn $"{i}"
         },
         fun oce -> printfn $"Computation Cancelled: {i}")
     |> Async.Start

 Thread.Sleep(6000)
 Async.CancelDefaultToken()
 printfn "Tasks Finished"
val primes: int list
val i: int
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.TryCancelled: computation: Async<'T> * compensation: (System.OperationCanceledException -> unit) -> Async<'T>
val async: AsyncBuilder
static member Async.Sleep: dueTime: System.TimeSpan -> Async<unit>
static member Async.Sleep: millisecondsDueTime: int -> Async<unit>
val printfn: format: Printf.TextWriterFormat<'T> -> 'T
val oce: System.OperationCanceledException
static member Async.Start: computation: Async<unit> * ?cancellationToken: System.Threading.CancellationToken -> unit
static member Async.CancelDefaultToken: unit -> unit
This will print "2" 2 seconds from start, "3" 3 seconds from start, "5" 5 seconds from start, cease computation and then print "Computation Cancelled: 7", "Computation Cancelled: 11" and "Tasks Finished" in any order.

Threads and Contexts

Static members

Static member Description

Async.SwitchToContext(syncContext)

Full Usage: Async.SwitchToContext(syncContext)

Parameters:
Returns: Async<unit> An asynchronous computation that uses the syncContext context to execute.

Creates an asynchronous computation that runs its continuation using syncContext.Post. If syncContext is null then the asynchronous computation is equivalent to SwitchToThreadPool().

syncContext : SynchronizationContext

The synchronization context to accept the posted computation.

Returns: Async<unit>

An asynchronous computation that uses the syncContext context to execute.

Async.SwitchToNewThread()

Full Usage: Async.SwitchToNewThread()

Returns: Async<unit> A computation that will execute on a new thread.

Creates an asynchronous computation that creates a new thread and runs its continuation in that thread.

Returns: Async<unit>

A computation that will execute on a new thread.

Example

 async {
     do! Async.SwitchToNewThread()
     do! someLongRunningComputation()
 } |> Async.StartImmediate
val async: AsyncBuilder
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.SwitchToNewThread: unit -> Async<unit>
static member Async.StartImmediate: computation: Async<unit> * ?cancellationToken: System.Threading.CancellationToken -> unit
This will run someLongRunningComputation() without blocking the threads in the threadpool.

Async.SwitchToThreadPool()

Full Usage: Async.SwitchToThreadPool()

Returns: Async<unit> A computation that generates a new work item in the thread pool.

Creates an asynchronous computation that queues a work item that runs its continuation.

Returns: Async<unit>

A computation that generates a new work item in the thread pool.

Example

 async {
     do! Async.SwitchToNewThread()
     do! someLongRunningComputation()
     do! Async.SwitchToThreadPool()

     for i in 1 .. 10 do
         do! someShortRunningComputation()
 } |> Async.StartImmediate
val async: AsyncBuilder
Multiple items
type Async = static member AsBeginEnd: computation: ('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) static member AwaitEvent: event: IEvent<'Del,'T> * ?cancelAction: (unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate) static member AwaitIAsyncResult: iar: IAsyncResult * ?millisecondsTimeout: int -> Async<bool> static member AwaitTask: task: Task<'T> -> Async<'T> + 1 overload static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout: int -> Async<bool> static member CancelDefaultToken: unit -> unit static member Catch: computation: Async<'T> -> Async<Choice<'T,exn>> static member Choice: computations: Async<'T option> seq -> Async<'T option> static member FromBeginEnd: beginAction: (AsyncCallback * obj -> IAsyncResult) * endAction: (IAsyncResult -> 'T) * ?cancelAction: (unit -> unit) -> Async<'T> + 3 overloads static member FromContinuations: callback: (('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> ...

--------------------
type Async<'T>
static member Async.SwitchToNewThread: unit -> Async<unit>
static member Async.SwitchToThreadPool: unit -> Async<unit>
val i: int
static member Async.StartImmediate: computation: Async<unit> * ?cancellationToken: System.Threading.CancellationToken -> unit
This will run someLongRunningComputation() without blocking the threads in the threadpool, and then switch to the threadpool for shorter computations.

Legacy .NET Async Interoperability

Static members

Static member Description

Async.AsBeginEnd(computation)

Full Usage: Async.AsBeginEnd(computation)

Parameters:
    computation : 'Arg -> Async<'T> - A function generating the asynchronous computation to split into the traditional .NET Asynchronous Programming Model.

Returns: ('Arg * AsyncCallback * objnull -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit) A tuple of the begin, end, and cancel members.

Creates three functions that can be used to implement the .NET 1.0 Asynchronous Programming Model (APM) for a given asynchronous computation.

computation : 'Arg -> Async<'T>

A function generating the asynchronous computation to split into the traditional .NET Asynchronous Programming Model.

Returns: ('Arg * AsyncCallback * objnull -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit)

A tuple of the begin, end, and cancel members.

Async.FromBeginEnd(arg1, arg2, arg3, beginAction, endAction, ?cancelAction)

Full Usage: Async.FromBeginEnd(arg1, arg2, arg3, beginAction, endAction, ?cancelAction)

Parameters:
    arg1 : 'Arg1 - The first argument for the operation.
    arg2 : 'Arg2 - The second argument for the operation.
    arg3 : 'Arg3 - The third argument for the operation.
    beginAction : 'Arg1 * 'Arg2 * 'Arg3 * AsyncCallback * objnull -> IAsyncResult - The function initiating a traditional CLI asynchronous operation.
    endAction : IAsyncResult -> 'T - The function completing a traditional CLI asynchronous operation.
    ?cancelAction : unit -> unit - An optional function to be executed when a cancellation is requested.

Returns: Async<'T> An asynchronous computation wrapping the given Begin/End functions.

Creates an asynchronous computation in terms of a Begin/End pair of actions in the style used in .NET 2.0 APIs.

The computation will respond to cancellation while waiting for the completion of the operation. If a cancellation occurs, and cancelAction is specified, then it is executed, and the computation continues to wait for the completion of the operation. If cancelAction is not specified, then cancellation causes the computation to stop immediately, and subsequent invocations of the callback are ignored.

arg1 : 'Arg1

The first argument for the operation.

arg2 : 'Arg2

The second argument for the operation.

arg3 : 'Arg3

The third argument for the operation.

beginAction : 'Arg1 * 'Arg2 * 'Arg3 * AsyncCallback * objnull -> IAsyncResult

The function initiating a traditional CLI asynchronous operation.

endAction : IAsyncResult -> 'T

The function completing a traditional CLI asynchronous operation.

?cancelAction : unit -> unit

An optional function to be executed when a cancellation is requested.

Returns: Async<'T>

An asynchronous computation wrapping the given Begin/End functions.

Async.FromBeginEnd(arg1, arg2, beginAction, endAction, ?cancelAction)

Full Usage: Async.FromBeginEnd(arg1, arg2, beginAction, endAction, ?cancelAction)

Parameters:
    arg1 : 'Arg1 - The first argument for the operation.
    arg2 : 'Arg2 - The second argument for the operation.
    beginAction : 'Arg1 * 'Arg2 * AsyncCallback * objnull -> IAsyncResult - The function initiating a traditional CLI asynchronous operation.
    endAction : IAsyncResult -> 'T - The function completing a traditional CLI asynchronous operation.
    ?cancelAction : unit -> unit - An optional function to be executed when a cancellation is requested.

Returns: Async<'T> An asynchronous computation wrapping the given Begin/End functions.

Creates an asynchronous computation in terms of a Begin/End pair of actions in the style used in .NET 2.0 APIs.

The computation will respond to cancellation while waiting for the completion of the operation. If a cancellation occurs, and cancelAction is specified, then it is executed, and the computation continues to wait for the completion of the operation. If cancelAction is not specified, then cancellation causes the computation to stop immediately, and subsequent invocations of the callback are ignored.

arg1 : 'Arg1

The first argument for the operation.

arg2 : 'Arg2

The second argument for the operation.

beginAction : 'Arg1 * 'Arg2 * AsyncCallback * objnull -> IAsyncResult

The function initiating a traditional CLI asynchronous operation.

endAction : IAsyncResult -> 'T

The function completing a traditional CLI asynchronous operation.

?cancelAction : unit -> unit

An optional function to be executed when a cancellation is requested.

Returns: Async<'T>

An asynchronous computation wrapping the given Begin/End functions.

Async.FromBeginEnd(arg, beginAction, endAction, ?cancelAction)

Full Usage: Async.FromBeginEnd(arg, beginAction, endAction, ?cancelAction)

Parameters:
    arg : 'Arg1 - The argument for the operation.
    beginAction : 'Arg1 * AsyncCallback * objnull -> IAsyncResult - The function initiating a traditional CLI asynchronous operation.
    endAction : IAsyncResult -> 'T - The function completing a traditional CLI asynchronous operation.
    ?cancelAction : unit -> unit - An optional function to be executed when a cancellation is requested.

Returns: Async<'T> An asynchronous computation wrapping the given Begin/End functions.

Creates an asynchronous computation in terms of a Begin/End pair of actions in the style used in .NET 2.0 APIs.

The computation will respond to cancellation while waiting for the completion of the operation. If a cancellation occurs, and cancelAction is specified, then it is executed, and the computation continues to wait for the completion of the operation. If cancelAction is not specified, then cancellation causes the computation to stop immediately, and subsequent invocations of the callback are ignored.

arg : 'Arg1

The argument for the operation.

beginAction : 'Arg1 * AsyncCallback * objnull -> IAsyncResult

The function initiating a traditional CLI asynchronous operation.

endAction : IAsyncResult -> 'T

The function completing a traditional CLI asynchronous operation.

?cancelAction : unit -> unit

An optional function to be executed when a cancellation is requested.

Returns: Async<'T>

An asynchronous computation wrapping the given Begin/End functions.

Async.FromBeginEnd(beginAction, endAction, ?cancelAction)

Full Usage: Async.FromBeginEnd(beginAction, endAction, ?cancelAction)

Parameters:
    beginAction : AsyncCallback * objnull -> IAsyncResult - The function initiating a traditional CLI asynchronous operation.
    endAction : IAsyncResult -> 'T - The function completing a traditional CLI asynchronous operation.
    ?cancelAction : unit -> unit - An optional function to be executed when a cancellation is requested.

Returns: Async<'T> An asynchronous computation wrapping the given Begin/End functions.

Creates an asynchronous computation in terms of a Begin/End pair of actions in the style used in CLI APIs.

The computation will respond to cancellation while waiting for the completion of the operation. If a cancellation occurs, and cancelAction is specified, then it is executed, and the computation continues to wait for the completion of the operation. If cancelAction is not specified, then cancellation causes the computation to stop immediately, and subsequent invocations of the callback are ignored.

beginAction : AsyncCallback * objnull -> IAsyncResult

The function initiating a traditional CLI asynchronous operation.

endAction : IAsyncResult -> 'T

The function completing a traditional CLI asynchronous operation.

?cancelAction : unit -> unit

An optional function to be executed when a cancellation is requested.

Returns: Async<'T>

An asynchronous computation wrapping the given Begin/End functions.

Type something to start searching.