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

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

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

Derleme: FSharp.Core (FSharp.Core.dll içinde)

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

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

Parametreler

• computation
  Tür: Async<'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 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.

Açıklamalar

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 iptal belirteci kullanılır. Zaman aşımı parametresi, milisaniye cinsinden. -1 Değeri eşdeğeri olan Infinite.

Async.RunSynchronouslyzaman uyumsuz programlama ortamlarında, ana iş parçacığı üzerinde gibi Silverlight tabanlı uygulamalarda kullanılmamalıdır.

Örnek

Aşağıdaki örnek, nasıl kullanılacağını gösterir Async.RunSynchronously bir zaman uyumsuz hesaplaması kullanılarak oluşturulan ç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 zaman aşımı.

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 7, Windows Vista SP2, Windows XP SP3, Windows XP x64 SP2, Windows Server 2008 R2, Windows Server 2008 SP2, Windows Server 2003 SP2

Sürüm Bilgisi

F# Çalışma Zamanı

Desteklenir: 2.0, 4.0

Silverlight

Desteklenir: 3

Ayrıca bkz.

Başvuru

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

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

Değişiklik Geçmişi

Tarih	Geçmiş	Nedeni
Temmuz 2010	Eklenen kod örnekleri.	Bilgi geliştirme.