Async.RunSynchronously<'T> Yöntemi (F#)

Makale
02/28/2013

Zaman uyumsuz hesaplaması çalıştırır ve sonucu bekler.

Ad alanı/modül yolu: Microsoft.FSharp.Control

Derleme: FSharp.Core (FSharp.Core.dll),

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

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

Parametreler

computation
Türü: zaman uyumsuz<'T>

Çalıştırılacak hesaplama.
timeout
Türü: int

Hesaplamanın sonucunun TimeoutException özel durumu oluşturulmadan önce milisaniye cinsinden beklediği süre. Hiçbir değeri zaman aşımı için sağlanan sonra karşılık için kullanılan varsayılan değeri -1 Infinite.
cancellationToken
Türü: CancellationToken

Hesaplama ile ilişkilendirilecek iptal belirteci. Bir belirteç sağlanmazsa, varsayılan iptali belirteci kullanılır.

Dönüş Değeri

Hesaplama sonucu.

Notlar

Zaman uyumsuz hesaplamada özel bir durum oluşursa, özel durum bu işlev tarafından yeniden oluşturulur. İptali belirteci sağlanmamışsa varsayılan iptali belirteci kullanılır. Zaman aşımı parametresi, milisaniye cinsinden. -1 Değeri eşdeğeri olan Infinite.

Async.RunSynchronouslyTemel ana iş parçacığı olacak olarak - zaman uyumsuz programlama ortamlarında uygulamaları kullanılmamalıdır.

Örnek

Aşağıdaki örnek, nasıl kullanılacağını gösterir Async.RunSynchronously kullanılarak oluşturulmuş bir zaman uyumsuz hesaplaması çalıştırmak için Async.Parallel, hiçbir zaman aşımı ile.

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

Aşağıdaki örnek, nasıl kullanılacağını gösterir Async.RunSynchronously bir zaman aşımı ile.

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

Örnek Çıktı

Platformlar

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

Sürüm Bilgisi

F# Çekirdek Kitaplığı sürümleri

Desteklenen: 2.0, 4.0, Portable

Ayrıca bkz.

Başvuru

Control.Async Sınıfı (F#)

Microsoft.FSharp.Control İsim Uzayı (F#)

Aracılığıyla paylaş