Verarbeitet MailboxProcessor nur IObservable?

Question

ich Typen einer Nachricht verarbeiten wollen

Add x macht erinnern Programmnummer x

Print macht es zu merkende Nummern

drucken Warum würde ich dieses schreiben:

open System 
type Message = 
    | Add of int 
    | Print 
let mailbox = new MailboxProcessor<Message>(fun inbox -> 
     let rec loop history = async{ 
      let! msg=inbox.Receive() 
      match msg with 
       | Add x -> return! loop(history + x.ToString()+" ") 
       | Print -> 
        printfn "%s" history 
        return! loop(history) 
     } 
     loop "" 
    ) 
[<EntryPoint>] 
let main argv = 
    mailbox.Start() 
    mailbox.Post(Add 12) 
    mailbox.Post(Add 56) 
    mailbox.Post(Print) 
    mailbox.Post(Add 34) 
    mailbox.Post(Print) 
    ignore <| Console.ReadLine() 
    0 

statt davon:

open System 
open System.Reactive.Subjects 
type Message = 
    | Add of int 
    | Print 
let subject = new Subject<Message>() 
[<EntryPoint>] 
let main argv = 
    subject 
     |> Observable.scan(fun history msg -> 
       match msg with 
         | Add x -> history + x.ToString()+" " 
         | Print -> 
          printfn "%s" history 
          history 
      ) "" 
     |> Observable.subscribe(fun _->()) 
     |> ignore 
    subject.OnNext(Add 12) 
    subject.OnNext(Add 56) 
    subject.OnNext(Print) 
    subject.OnNext(Add 34) 
    subject.OnNext(Print) 
    ignore <| Console.ReadLine() 
    0 

Die MailboxProcessor fügt zusätzliche Komplexität hinzu. Ich brauche eine Zustandsmaschine, die einen Zustand annimmt und einen Zustand zurückgibt. Aber es zwingt mich, inbox zu nehmen, die verwendet wird, um Zustand zu erhalten.

Hat es irgendwelche Vorteile zu IObservable?

Answer 1

Nein, sie sind keine Duplikate voneinander. MailboxProcessor und IObservable sind Low-Level-Bausteine ​​von zwei verschiedenen Modellen der Berechnung - Actor-Modell bzw. funktionale reaktive Programmierung.

Beide befassen sich mit Asynchronität, sondern betonen different qualities. Es ist vielleicht möglich, Ihre Lösung in Bezug auf das eine oder das andere zu erstellen - wie Sie in Ihrem einfachen Beispiel bemerkt haben -, aber Sie werden das eine oder andere für einen bestimmten Kontext natürlicher finden.

MailboxProcessors sind besonders nützlich für thread-sicheren, lock-freien Zugriff auf eine Ressource, z. B. eine Datei. Sie können mehrere Threads verwenden, die die Ressource über eine asynchrone Schnittstelle manipulieren, und MailboxProcessor garantiert, dass nur eine dieser Anforderungen gleichzeitig verarbeitet wird.