Método Async.RunSynchronously<'T> (F#)

Artigo
06/10/2015

Executa a computação assíncrona fornecida e aguarda o resultado.

Caminho do namespace/módulo: Microsoft.FSharp.Control

Assembly: FSharp.Core (em FSharp.Core.dll)

// Signature:
static member RunSynchronously : Async<'T> * ?int * ?CancellationToken -> 'T

// Usage:
Async.RunSynchronously (computation)
Async.RunSynchronously (computation, timeout = timeout, cancellationToken = cancellationToken)

Parâmetros

computation
Tipo: Async<'T>

O cálculo a ser executado.
timeout
Tipo: int

A quantidade de tempo em milissegundos para aguardar o resultado da computação antes de gerar uma TimeoutException. Se nenhum valor for fornecido para o tempo limite, um padrão de -1 será usado para corresponder a Infinite.
cancellationToken
Tipo: CancellationToken

O token de cancelamento a ser associado ao cálculo. Se não for fornecido, o token de cancelamento padrão será usado.

Valor de retorno

O resultado do cálculo.

Comentários

Se ocorrer uma exceção na computação assíncrona, uma exceção será gerada novamente por essa função. Se nenhum token de cancelamento for fornecido, o token padrão de cancelamento será usado. O parâmetro de tempo limite é fornecido em milissegundos. Um valor de -1 é equivalente a Infinite.

Se você fornecer um token de cancelamento anulável, o tempo limite será ignorado. Em vez disso, você pode implementar seu próprio tempo limite cancelando a operação. Um token de cancelamento será anulável se sua propriedade de CanBeCanceled for definida como true.

Async.RunSynchronously não deve ser usado no thread principal em ambientes de programação assíncrona, como em aplicativos baseados no Silverlight.

Exemplo

O exemplo a seguir mostra como usar Async.RunSynchronously para executar uma computação assíncrona criada usando Async.Parallel sem o tempo limite.

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

O exemplo a seguir mostra como usar Async.RunSynchronously com tempo limite.

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

Saída de Exemplo

Plataformas

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

Informações de versão

Versões da biblioteca principal F#

Suportado em: 2.0, 4.0, Portátil

Consulte também

Referência

Classe Control.Async (F#)

Namespace Microsoft.FSharp.Control (F#)

Partilhar via