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

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é 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 7, Windows Vista SP2, Windows XP SP3, Windows XP x64 SP2, Windows Server 2008 R2, Windows Server 2008 SP2, Windows Server 2003 SP2

Informations de version

Runtime F#

Pris en charge dans : 2.0, 4.0

Silverlight

Prise en charge dans : 3

Voir aussi

Référence

Control.Async, classe (F#)

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

Historique des modifications

Date	Historique	Motif
Juillet 2010	Ajout d'exemples de code.	Améliorations apportées aux informations.