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

Executa a computação assíncrona e aguarda o seu 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>

  A computação seja executado.

• timeout
  Tipo: int

  A quantidade de tempo em milissegundos para aguardar o resultado da computação antes de disparar um TimeoutException. Se nenhum valor é fornecido para o tempo limite e um padrão de -1 é usado para corresponder à Infinite.

• cancellationToken
  Tipo: CancellationToken

  O token de cancelamento para ser associado com a computação. Se não for fornecida, o símbolo de cancelamento padrão é usado.

Valor de retorno

O resultado da computação.

Comentários

Se ocorrer uma exceção na computação assíncrona uma exceção é re-raised por essa função. Se nenhum token de cancelamento é fornecido o símbolo de cancelamento padrão é usado. Recebe o parâmetro de tempo limite em milissegundos. Um valor -1 é equivalente a Infinite.

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

Exemplo

O exemplo a seguir mostra como usar Async.RunSynchronously para executar uma computação assíncrona criada usando Async, sem 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 um 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

O Windows 7, SP2 do Windows Vista, Windows XP SP3, Windows XP Professional x64 SP2, Windows Server 2008 R2, Windows Server 2008 SP2, Windows Server 2003 SP2

Informações sobre versão

O tempo de execução F#

Compatível com: 2.0, 4.0

Silverlight

Compatível com: 3

Consulte também

Referência

Classe Control.Async (F#)

Microsoft.FSharp.Control Namespace (F#)

Histórico de alterações

Date	History	Motivo
Julho de 2010	Exemplos de código adicionado.	Aprimoramento de informações.