Async.RunSynchronously<'T> – metoda (F#)

Článek
06/10/2015

Spustí poskytnutý asynchronní výpočet a počká na jeho výsledek.

Obor názvů/cesta modulu: Microsoft.FSharp.Control

Sestavení: FSharp.Core (v 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
Zadejte: Async<'T>

Výpočet pro spuštění.
timeout
Zadejte: int

Doba v milisekundách, kterou se má čekat na výsledek výpočtu před vyvoláním TimeoutException.Pokud není zadána žádná hodnota časového limitu, použije se výchozí hodnota -1, aby odpovídala Infinite.
cancellationToken
Zadejte: CancellationToken

Token rušení, který chcete přidružit k výpočtu.Pokud jeden není zadán, použije se výchozí token zrušení.

Vrácená hodnota

Výsledek výpočtu.

Poznámky

Pokud dojde k výjimce v asynchronním výpočtu pak je znovu vyvolána výjimka touto funkcí.Pokud není k dispozici žádný token zrušení, používá se výchozí token zrušení.Parametr časového limitu je uveden v milisekundách.Hodnota -1 je ekvivalentem k Infinite.

Pokud zadáte zrušitelný rušící tokenu, je ignorován časový limit.Místo toho můžete implementovat vlastní časový limit zrušením operace.Rušící token je možné zrušit, pokud jeho vlastnost CanBeCanceled je nastavena na true.

Async.RunSynchronously není vhodné používat na hlavní podproces v asynchronních programovacích prostředích, například v aplikacích založených na Silverlight.

Příklad

Následující příklad ukazuje, jak použít Async.RunSynchronously ke spuštění asynchronního výpočtu vytvořeného pomocí Async.Parallel bez časového limitu.

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

Následující příklad ukazuj použití Async.RunSynchronously s časovým limitem.

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

Výstup ukázky

Platformy

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

Informace o verzi

Verze základní knihovny F#

Podporováno ve verzích: 2.0, 4.0, Portable

Viz také

Referenční dokumentace

Control.Async – třída (F#)

Microsoft.FSharp.Control – obor názvů (F#)

Sdílet prostřednictvím