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

Articolo
06/10/2015

Esegue il calcolo asincrono fornito ed 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 TimeoutException Se 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.

Se si fornisce un token di annullamento revocabile, il timeout viene ignorato. In alternativa, è possibile implementare il proprio timeout tramite l'annullamento dell'operazione. Un token di annullamento è annullabile se la sua proprietà CanBeCanceled è impostata su true.

Async.RunSynchronously non deve essere utilizzato nel thread principale in ambienti di programmazione asincrona, ad esempio in applicazioni basate su Silverlight.

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 di F#

Supportato in: 2.0, 4.0, portabile

Vedere anche

Riferimenti

Classe Control.Async (F#)

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

Condividi tramite