Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Metodo Async.RunSynchronously<'T> (F#)

Esegue il calcolo asincrono e attende il relativo risultato.

Percorso di spazio dei nomi/modulo: 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)

computation

Tipo: Async<'T>

Calcolo da eseguire.

timeout

Tipo: int

Quantità di tempo, in millisecondi, di attesa del risultato del calcolo prima di generare un'eccezione TimeoutException Se per il timeout non viene fornito alcun valore, viene utilizzato un valore predefinito -1 in modo che corrisponde a Infinite.

cancellationToken

Tipo: CancellationToken

Token di annullamento da associare al calcolo. Se non ne viene fornito alcuno, viene utilizzato il token di annullamento predefinito.

Risultato del calcolo.

Se durante il calcolo asincrono si verifica un'eccezione, viene nuovamente generata un'eccezione da questa funzione. Se non viene specificato alcun token di annullamento, viene utilizzato il token di annullamento predefinito. Il parametro di timeout viene specificato in millisecondi. Valore di -1 equivale a Infinite.

Async.RunSynchronously non deve essere utilizzato il thread principale in ambienti di programmazione asincrona, come in applicazioni basate su.

Nell'esempio riportato di seguito viene illustrato come utilizzare Async.RunSynchronously per eseguire un calcolo asincrono creato tramite Async.Parallel, senza timeout.


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


            
          

Nell'esempio riportato di seguito viene illustrato come utilizzare Async.RunSynchronously con un timeout.


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


Esempio di output

            
              Timeout dell'operazione.
            
            
              420 operazioni di scrittura completate correttamente.
            
          

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

Versioni della libreria di base F#

Supportato in: 2,0, 4,0, portabile

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft