MailboxProcessor.TryScan<'Msg,'T> Yöntemi (F#)

Makale
02/28/2013

Bir iletinin geliş sırasına iletiler yoluyla sağlanan işlev dönünceye kadar bakarak tarar bir Some değeri. Diğer iletiler sırada kalır.

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

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

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

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

Parametreler

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

Döndüren bir işlev None ileti atlanması için ise ya da Some ileti işlenir ve sıradan kaldırılan ise.
timeout
Türü: int

İsteğe bağlı milisaniye cinsinden zaman aşımı. Infinite'e karşılık gelir ve varsayılan olarak -1'dir.

Dönüş Değeri

Zaman uyumsuz bir hesaplama (zaman uyumsuz nesnesi), scanner okuma iletinin yerleşik.

Notlar

Zaman aşımı süresi aşılırsa, None döndürülür. Bu yöntem aracının gövdesi içinde kullanılır. Her aracı için en fazla eşzamanlı bir okuyucu etkin olabilir bu nedenle birden fazla eş zamanlı çağrı Al, TryReceive, Tarama veya TryScan etkin olabilir. Gövdesi scanner işlevi yürütmesi sırasında kilitli ancak kilit zaman uyumsuz iş akışının yürütülmesini önce serbest bırakılmış.

Örnek

Aşağıdaki kod örneği nasıl kullanılacağını gösteren TryScan yöntemi. Bu örnek bir proje Sunuşu aracısıdır. Üç aracıları vardır: adlı bir runAgent , her işi başlatır ve başka bir adı verilen inprogressAgent temsil eden tüm çalışan işleri ve adı verilen bir completeAgent temsil eden bir işi tamamlandı bildirimi. TryScankullanılan cancelJob iptal etmek için bir iş bulmak için işlev veya eşleşen hiçbir iş ise başarısız.

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

Aşağıdaki örnek bir oturumdur.

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.MailboxProcessor<'Msg> Sınıfı (F#)

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

Aracılığıyla paylaş