Async.RunSynchronously<'T>, méthode (F#)
Exécute le calcul asynchrone fourni 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 : intDé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 : CancellationTokenJeton 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.
Si vous fournissez un jeton annulable d'annulation, le délai d'attente est ignoré. À la place, il vous est possible d'implémenter votre propre délai d'attente en annulant l'opération. Un jeton d'annulation est annulable si sa propriété CanBeCanceled détient la valeur true.
Async.RunSynchronously ne doit pas être utilisé dans le thread principal dans les environnements de programmation asynchrones, comme dans les applications Silverlight.
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 la bibliothèque principale F#
Prise en charge dans : 2,0, 4,0, Portable