Async.RunSynchronously<'T>, méthode (F#)

Article
02/19/2013

Exécute le calcul asynchrone et attend son résultat.

Espace de noms/Chemin du module : 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)

Paramètres

computation
Type : Async<'T>

Calcul à exécuter.
timeout
Type : int

Délai d'attente, en millisecondes, du résultat du calcul avant de lever une TimeoutException.Si aucune valeur n'est fournie pour le délai d'attente, une valeur par défaut de -1 est utilisée pour correspondre à Infinite.
cancellationToken
Type : CancellationToken

Jeton d'annulation à associer au calcul.Si aucun jeton n'est fourni, le jeton d'annulation par défaut est utilisé.

Valeur de retour

Résultat du calcul.

Notes

Si une exception se produit dans le calcul asynchrone, une exception est à nouveau levée par cette fonction.Si aucun jeton d'annulation n'est fourni, le jeton d'annulation par défaut est utilisé.Le paramètre de délai d'attente est donné en millisecondes.Une valeur de -1 est équivalente à Infinite.

Async.RunSynchronously ne doit pas être utilisé sur le thread principal dans les environnements de programmation asynchrones, comme dans les applications.

Exemple

L'exemple suivant montre comment utiliser Async.RunSynchronously pour exécuter un calcul asynchrone créé à l'aide de Async.Parallel, sans délai d'attente.

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

L'exemple suivant montre comment utiliser Async.RunSynchronously avec un délai d'attente.

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

Résultat de l'exemple

Plateformes

Windows 8, Windows 7, Windows Server 2012, Windows Server 2008 R2

Informations de version

Versions de bibliothèque principale F#

Prise en charge dans : 2,0, 4,0, portables

Voir aussi

Référence

Control.Async, classe (F#)

Microsoft.FSharp.Control, espace de noms (F#)

Partager via