MailboxProcessor.TryScan < "Msg, t > Metoda (F#)

Článek
02/28/2013

Vyhledává zprávy zaměřením v pořadí doručení zpráv dokud poskytované funkce vrací Some hodnotu.Ostatní zprávy zůstávají ve frontě.

Cesta k oboru názvů nebo modul: Microsoft.FSharp.Control

Sestavení: FSharp.Core (v FSharp.Core.dll)

// Signature:
member this.TryScan : ('Msg -> Async<'T> option) * ?int -> Async<'T option>

// Usage:
mailboxProcessor.TryScan (scanner)
mailboxProcessor.TryScan (scanner, timeout = timeout)

Parametry

scanner
Type: 'Msg -> Async<'T> option

Funkce, která vrací None -li zpráva vynechána, nebo Some Pokud je zpráva zpracována a odebrána z fronty.
timeout
Typ: int

Volitelné časový limit v milisekundách.Výchozí hodnotu -1, který odpovídá Infinite.

Vrácená hodnota

Asynchronní výpočtu (asynchronní objektu), scanner vytvořené vypnutí čtení zprávy.

Poznámky

Pokud je překročen časový limit, None je vrácena.Tato metoda je pro použití v rámci těla agent.Každý agent může být maximálně jeden Čtenář souběžné aktivní, tak více než jeden souběžných volání příjem, TryReceive, prohledávání nebo TryScan může být aktivní.Text scanner funkce je uzamčen během jeho provádění, ale před spuštěním pracovního postupu asynchronní uvolnění uzamčení.

Příklad

Následující příklad kódu ukazuje, jak použít TryScan metoda.V tomto příkladu je činitel odeslání úlohy.Existují tři agenti: jeden s názvem runAgent , Každá úloha spustí, jiný nazvaný inprogressAgent , představuje všechny spuštěné úlohy a názvem jedné completeAgent , představuje oznámení ukončení úlohy.TryScanpoužívá se cancelJob funkce najít úlohu zrušit nebo pokud neexistuje žádná odpovídající úloha nezdaří.

open System
open System.Threading

let random = System.Random()


// Generates mock jobs by using Async.Sleep.
let createJob(id:int, source:CancellationTokenSource) =
    let job = async {
        // Let the time be a random number between 1 and 10000.
        // The mock computed result is a floating point value.
        let time = random.Next(10000)
        let result = random.NextDouble()
        let count = ref 1
        while (!count <= 100 && not source.IsCancellationRequested) do
            do! Async.Sleep(time / 100)
            count := !count + 1
        return result
        }
    id, job, source

type Result = double

// A Job consists of a job ID, a computation that produces a single result,
// and a cancellation token source object that can be used to cancel the job.
type Job = int * Async<Result> * CancellationTokenSource

type Message = int * Result

let context = System.Threading.SynchronizationContext.Current

// This agent processes when jobs are completed.
let completeAgent = MailboxProcessor<Message>.Start(fun inbox ->
    let rec loop n =
        async {
            let! (id, result) = inbox.Receive()
            printfn "The result of job #%d is %f" id result
            do! loop (n + 1)
        }
    loop (0))

// inprogressAgent maintains a queue of in-progress jobs that can be
// scanned to remove canceled jobs. It never runs its processor function,
// so we set it to do nothing.
let inprogressAgent = new MailboxProcessor<Job>(fun _ -> async { () })

// This agent starts each job in the order in which it is received.
let runAgent = MailboxProcessor<Job>.Start(fun inbox ->
    let rec loop n =
        async {          
            let! (id, job, source) = inbox.Receive()
            printfn "Starting job #%d" id
            // Post to the in-progress queue.
            inprogressAgent.Post(id, job, source)
            // Start the job.
            Async.StartWithContinuations(job,
                (fun result -> completeAgent.Post(id, result)),
                (fun _ -> ()),
                (fun cancelException -> printfn "Canceled job #%d" id),
                source.Token)
            do! loop (n + 1)
            }
    loop (0))

for id in 1 .. 10 do
    let source = new CancellationTokenSource()
    runAgent.Post(createJob(id, source))

let cancelJob(cancelId) =
    Async.RunSynchronously(
         inprogressAgent.TryScan((fun (jobId, result, source) ->
                let action =
                    async {
                        printfn "Canceling job #%d" cancelId
                        source.Cancel()
                        return cancelId
                    }
                // Return Some(async) if the job ID matches.
                if (jobId = cancelId) then
                    Some(action)
                else
                    None), 1000))


printfn "Specify a job by number to cancel it, then press Enter."

let mutable finished = false
while not finished do
    let input = System.Console.ReadLine()
    let a = ref 0
    if (Int32.TryParse(input, a) = true) then
        match cancelJob(!a) with
        | Some id -> printfn "A job was canceled: job #%d" id
        | None -> printfn "Job not found."
    else
        printfn "Terminating."
        finished <- true

Následuje v relaci příklad.

Platformy

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

Informace o verzi

F# základní verze knihovny

Podporovány: 2.0, 4.0, přenosné

Viz také

Referenční dokumentace

Control.MailboxProcessor < "Msg > Třídy (F#)

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

Sdílet prostřednictvím