Metodo Async.RunSynchronously<'T> (F#)

Esegue il calcolo asincrono e attende il relativo risultato.

Percorso di spazio dei nomi/modulo: 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)

Parametri

• computation
  Tipo: Async<'T>

  Calcolo da eseguire.

• timeout
  Tipo: int

  Quantità di tempo, in millisecondi, di attesa del risultato del calcolo prima di generare un'eccezione TimeoutExceptionSe per il timeout non viene fornito alcun valore, viene utilizzato un valore predefinito -1 in modo che corrisponde a Infinite.

• cancellationToken
  Tipo: CancellationToken

  Token di annullamento da associare al calcolo.Se non ne viene fornito alcuno, viene utilizzato il token di annullamento predefinito.

Valore restituito

Risultato del calcolo.

Note

Se durante il calcolo asincrono si verifica un'eccezione, viene nuovamente generata un'eccezione da questa funzione.Se non viene specificato alcun token di annullamento, viene utilizzato il token di annullamento predefinito.Il parametro di timeout viene specificato in millisecondi.Valore di -1 equivale a Infinite.

Async.RunSynchronously non deve essere utilizzato il thread principale in ambienti di programmazione asincrona, come in applicazioni basate su.

Esempio

Nell'esempio riportato di seguito viene illustrato come utilizzare Async.RunSynchronously per eseguire un calcolo asincrono creato tramite Async.Parallel, senza timeout.

let bufferData (number:int) =
    [| for count in 1 .. 1000 -> byte (count % 256) |]
    |> Array.permute (fun index -> index)

let writeFile fileName bufferData =
    async {
      use outputFile = System.IO.File.Create(fileName)
      do! outputFile.AsyncWrite(bufferData) 
    }

Seq.init 1000 (fun num -> bufferData num)
|> Seq.mapi (fun num value -> writeFile ("file" + num.ToString() + ".dat") value)
|> Async.Parallel
|> Async.RunSynchronously
|> ignore

Nell'esempio riportato di seguito viene illustrato come utilizzare Async.RunSynchronously con un timeout.

let bufferData (number:int) =
    [| for i in 1 .. 1000 -> byte (i % 256) |]
    |> Array.permute (fun index -> index)

// Create a counter as a reference cell that can be modified in parallel.
let counter = ref 0

// writeFileInner writes the data to an open stream
// that represents the file. It also updates the counter.

// The counter is locked because it will be accessed by
// multiple asynchronous computations.

// The counter must be updated as soon as the
// AsyncWrite completes, in the same synchronous
// program flow. There must not be a let! or do! between
// the AsyncWrite call and the counter update.
let writeFileInner (stream:System.IO.Stream) data =
    let result = stream.AsyncWrite(data)
    lock counter (fun () -> counter := !counter + 1)
    result

// writeFile encapsulates the asynchronous write operation.
// The do! includes both the file I/O operation and the
// counter update in order to keep those operations
// together.
let writeFile fileName bufferData =
    async {
      use outputFile = System.IO.File.Create(fileName)
      do! writeFileInner outputFile bufferData
      // Updating the counter here would not be effective.
    }

let async1 = Seq.init 1000 (fun num -> bufferData num)
             |> Seq.mapi (fun num value ->
                 writeFile ("file" + num.ToString() + ".dat") value)
             |> Async.Parallel
try
    Async.RunSynchronously(async1, 100) |> ignore
with
   | exc -> printfn "%s" exc.Message
            printfn "%d write operations completed successfully." !counter

Esempio di output

Piattaforme

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

Informazioni sulla versione

Versioni della libreria di base F#

Supportato in: 2,0, 4,0, portabile

Vedere anche

Riferimenti

Classe Control.Async (F#)

Spazio dei nomi Microsoft.FSharp.Control (F#)