Async.RunSynchronously<'T> — Metoda (F#)

Uruchamia dostarczone asynchroniczne obliczenie i czeka na jego wynik.

Przestrzeń nazw/Ścieżka modułu: Microsoft.FSharp.Control

Zestaw: FSharp.Core (w FSharp.Core.dll)

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

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

Parametry

• computation
  Wpisz: asynchroniczne<'T>

  Obliczenie do uruchomienia.

• timeout
  Wpisz: int

  Czas w milisekundach na oczekiwanie na wynik obliczeń przed podniesieniem TimeoutException.Jeśli nie podano żadnej wartości limitu czasu, wówczas wartość domyślna -1 jest używana, aby odpowiadać Infinite.

• cancellationToken
  Wpisz: Token anulowania

  Generator kodu anulowania do skojarzenia z zadaniem kontynuacji.Jeśli nie jest podany, domyślny token anulowania jest używany.

Wartość zwracana

Wynik obliczeń.

Uwagi

Jeśli wystąpi wyjątek w asynchronicznym obliczeniu, wówczas wyjątek jest ponownie uruchamiany przez tę funkcję.Jeśli nie jest dostępny token anulowania, wówczas domyślny token anulowania jest używany.Limit czasu jest podany w milisekundach.Wartość -1 odpowiada Infinite.

Jeśli podasz token anulowania właściwości cancelable, limit czasu jest ignorowany.Zamiast tego, można zaimplementować swój własny limit czasu anulując operację.Token odwołania jest unieważniany, jeśli jego właściwość CanBeCanceled ustawiono na true.

Async.RunSynchronously nie można stosować do głównego wątku w środowiskach programowania asynchronicznego, takich jak w aplikacjach opartych na technologii Silverlight.

Przykład

Poniższy przykład pokazuje, jak używać Async.RunSynchronously do uruchomienia asynchronicznych obliczeń utworzonych za pomocą Async.Parallel, bez limitu czasu.

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

Poniższy przykład pokazuje sposób wykorzystania Async.RunSynchronously z limitem czasu.

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

Przykładowe dane wyjściowe

Platformy

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

Informacje o wersji

Wersje podstawowe biblioteki języka F#

Obsługiwane przez: 2.0, 4.0, przenośne

Zobacz też

Informacje

Control.Async — Klasa (F#)

Microsoft.FSharp.Control — Przestrzeń nazw (F#)