Async.RunSynchronously<'T>-Methode (F#)

Artikel
02/20/2013

Führt die asynchrone Berechnung aus und wartet auf das Ergebnis.

Namespace/Modulpfad: 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)

Parameter

computation
Typ: Async<'T>

Die Berechnung, die ausgeführt werden soll.
timeout
Typ: int

Die Zeitdauer in Millisekunden, für die auf das Ergebnis der Berechnung gewartet werden soll, bevor eine TimeoutException ausgelöst wird.Wenn kein Wert für Timeout angegeben wird, wird ein Standardwert von -1 verwendet, um Infinite zu entsprechen.
cancellationToken
Typ: CancellationToken

Das Abbruchtoken, das der Berechnung zugeordnet werden soll.Wenn kein Token angegeben wird, wird das Standardabbruchtoken verwendet.

Rückgabewert

Das Ergebnis der Berechnung.

Hinweise

Wenn bei der asynchronen Berechnung eine Ausnahme auftritt, wird erneut eine Ausnahme von dieser Funktion ausgelöst.Wenn kein Abbruchtoken bereitgestellt wird, wird das Standardabbruchtoken verwendet.Der Timeoutparameter wird in Millisekunden angegeben.Ein Wert von -1 entspricht Infinite.

Async.RunSynchronously sollte nicht auf dem Hauptthread in der asynchronen Programmierumgebung, wie in - basierten Anwendungen verwendet werden.

Beispiel

Im folgenden Beispiel wird veranschaulicht, wie mit Async.RunSynchronously eine asynchrone Berechnung ohne Timeout ausgeführt wird, die mithilfe von Async.Parallel erstellt wurde.

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

Im folgenden Beispiel wird gezeigt, wie Async.RunSynchronously mit einem Timeout verwendet wird.

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

Beispielausgabe

Plattformen

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

Versionsinformationen

F#-Kern-Bibliotheks-Versionen

Unterstützt in: 2,0, 4,0, portablen

Siehe auch

Referenz

Control.Async-Klasse (F#)

Microsoft.FSharp.Control-Namespace (F#)

Freigeben über