Control.Observable-Modul (F#)

Grundlegende Vorgänge für Ereignis- und andere wahrnehmbare Objekte erster Klasse.

Namespace/Modulpfad: Microsoft.FSharp.Control

Assembly: FSharp.Core (in FSharp.Core.dll)

module Observable

Werte

Wert	Beschreibung
add : ('T -> unit) -> IObservable<'T> -> unit	Erstellt einen Beobachter, der das angegebene wahrnehmbare Element permanent abonniert und die angegebene Funktion für jede Beobachtung aufruft.
choose : ('T -> 'U option) -> IObservable<'T> -> IObservable<'U>	Gibt ein wahrnehmbares Element zurück, das mithilfe der angegebenen Funktion eine Projektion von Beobachtungen aus der Quelle auswählt. Das zurückgegebene Objekt löst Beobachtungen aus, für das der Splitter einen Some-Wertzurückgibt. Das zurückgegebene Objekt gibt auch alle Fehler weiter, die auf die Quelle zurückzuführen sind, und wird abgeschlossen, wenn die Quelle abgeschlossen wird.
filter : ('T -> bool) -> IObservable<'T> -> IObservable<'T>	Gibt ein wahrnehmbares Element zurück, das die Beobachtungen der Quelle nach der angegebenen Funktion filtert. Das wahrnehmbare Element erkennt nur die Beobachtungen, für die das Prädikat true zurückgibt. Das Prädikat wird einmal für jeden abonnierten Beobachter ausgeführt. Der zurückgegebene Typ gibt auch Fehlerbeobachtungen weiter, die in der Quelle entstehen, und wird abgeschlossen, wenn die Quelle abgeschlossen werden kann.
map : ('T -> 'U) -> IObservable<'T> -> IObservable<'U>	Gibt ein wahrnehmbares Element zurück, das die Beobachtungen der Quelle mit der angegebenen Funktion umwandelt. Die Transformationsfunktion wird für jeden abonnierten Beobachter einmal ausgeführt. Der zurückgegebene Typ gibt auch Fehlerbeobachtungen weiter, die in der Quelle entstehen, und wird abgeschlossen, wenn die Quelle abgeschlossen werden kann.
zusammenführen : IObservable<'T> -> IObservable<'T> -> IObservable<'T>	Gibt für die zusammengeführten Beobachtungen ein wahrnehmbares Element aus den Quellen zurück. Das zurückgegebene Objekt gibt Erfolgs- und Fehlerwerte aus beiden Quellen weiter und wird abgeschlossen, wenn beiden Quellen beendet wurden.
pairwise : IObservable<'T> -> IObservable<'T * 'T>	Gibt ein neues wahrnehmbares Objekt zurück, das bei der zweiten und weiteren Auslösungen der wahrnehmbaren Eingabe ausgelöst wird. Beim N-ten Auslösen der wahrnehmbaren Eingabe werden die Argumente von N-1-ten Auslösung und der N-ten Auslösung als Paar übergeben. Das beim N-1-ten Auslösen übergebene Argument verbleibt bis zum N-ten Auslösen in einem versteckten internen Zustand.
Partition : ('T -> bool) -> IObservable<'T> -> IObservable<'T> * IObservable<'T>	Gibt zwei wahrnehmbare Elemente zurück, die die Beobachtungen der Quelle durch die angegebene Funktion teilen. Das erste Element löst Beobachtungen für jene Werte aus, für die das Prädikat true zurückgibt. Das zweite Element löst Beobachtungen für jene Werte aus, für die das Prädikat false zurückgibt. Das Prädikat wird einmal für jeden abonnierten Beobachter ausgeführt. Darüber hinaus geben beide Elemente alle Fehlerbeobachtungen aus der Quelle weiter und werden abgeschlossen, wenn die Quelle beendet wird.
scan : ('U -> 'T -> 'U) -> 'U -> IObservable<'T> -> IObservable<'T>	Gibt ein wahrnehmbares Element zurück, das für jeden Beobachter ein Zustandselement zuweist und die angegebene Akkumulationsfunktion für aufeinander folgende Werte aus der Eingabe anwendet. Das zurückgegebene Objekt löst Beobachtungen für jeden berechneten Zustandswert mit Ausnahme des Anfangswerts aus. Das zurückgegebene Objekt gibt alle Fehler weiter, die auf die Quelle zurückzuführen sind, und wird abgeschlossen, wenn die Quelle abgeschlossen wird.
split : ('T -> Choice<'U1,'U2>) -> IObservable<'T> -> IObservable<'U1> * IObservable<'U2>	Gibt zwei wahrnehmbare Elemente zurück, die die Beobachtungen der Quelle durch die angegebene Funktion teilen. Das Erste löst Beobachtungen aus, für das der Splitter Choice1Of2 zurückgibt. Das zweite löst Beobachtungen y aus, für das der Splitter Choice2Of2 zurückgibt. Das Splitter wird einmal für jeden abonnierten Beobachter ausgeführt. Darüber hinaus geben beide Elemente Fehlerbeobachtungen aus der Quelle weiter und werden abgeschlossen, wenn die Quelle beendet wird.
subscribe : ('T -> unit) -> IObservable<'T> -> IDisposable	Erstellt einen Beobachter, der das angegebene wahrnehmbare Element abonniert und die angegebene Funktion für jede Beobachtung aufruft.

Beispiel

Im folgenden Codebeispiel wird die Verwendung von wahrnehmbaren Elementen veranschaulicht. Die in diesem Beispiel definierte ObserverSource-Klasse ist eine allgemeine wiederverwendbare Klasse, die Sie als Quelle wahrnehmbarer Ereignisse verwenden können. Beispiele für die Verwendung einiger Funktionen in diesem Modul werden hier angezeigt. Informationen zu Funktionen, die hier nicht erläutert werden, finden Sie in den Codebeispielen in Control.Event-Modul (F#).

open System
open System.Diagnostics

// Represents a stream of IObserver events.
type ObservableSource<'T>() =

    let protect function1 =
        let mutable ok = false
        try 
            function1()
            ok <- true
        finally
            Debug.Assert(ok, "IObserver method threw an exception.")

    let mutable key = 0

    // Use a Map, not a Dictionary, because callers might unsubscribe in the OnNext
    // method, so thread-safe snapshots of subscribers to iterate over are needed.
    let mutable subscriptions = Map.empty : Map<int, IObserver<'T>>

    let next(obs) = 
        subscriptions |> Seq.iter (fun (KeyValue(_, value)) -> 
            protect (fun () -> value.OnNext(obs)))

    let completed() = 
        subscriptions |> Seq.iter (fun (KeyValue(_, value)) -> 
            protect (fun () -> value.OnCompleted()))

    let error(err) = 
        subscriptions |> Seq.iter (fun (KeyValue(_, value)) -> 
            protect (fun () -> value.OnError(err)))

    let thisLock = new obj()

    let obs = 
        { new IObservable<'T> with
            member this.Subscribe(obs) =
                let key1 =
                    lock thisLock (fun () ->
                        let key1 = key
                        key <- key + 1
                        subscriptions <- subscriptions.Add(key1, obs)
                        key1)
                { new IDisposable with 
                    member this.Dispose() = 
                        lock thisLock (fun () -> 
                            subscriptions <- subscriptions.Remove(key1)) } }

    let mutable finished = false

    // The source ought to call these methods in serialized fashion (from
    // any thread, but serialized and non-reentrant).
    member this.Next(obs) =
        Debug.Assert(not finished, "IObserver is already finished")
        next obs

    member this.Completed() =
        Debug.Assert(not finished, "IObserver is already finished")
        finished <- true
        completed()

    member this.Error(err) =
        Debug.Assert(not finished, "IObserver is already finished")
        finished <- true
        error err

    // The IObservable object returned is thread-safe; you can subscribe 
    // and unsubscribe (Dispose) concurrently.
    member this.AsObservable = obs

// Create a source.
let source = new ObservableSource<int>()

// Get an IObservable from the source.
let obs = source.AsObservable 

// Add a simple subscriber.
let unsubA = obs |> Observable.subscribe (fun x -> printfn "A: %d" x)

// Send some messages from the source.
// Output: A: 1
source.Next(1)
// Output: A: 2
source.Next(2)

// Add another subscriber. This subscriber has a filter.
let unsubB =
    obs
    |> Observable.filter (fun num -> num % 2 = 0)
    |> Observable.subscribe (fun num -> printfn "B: %d" num)

// Send more messages from the source.
// Output: A: 3
source.Next(3)
// Output: A: 4
//         B: 4
source.Next(4)

// Have subscriber A unsubscribe.
unsubA.Dispose()

// Send more messages from the source.
// No output
source.Next(5)
// Output: B: 6
source.Next(6)

// If you use add, there is no way to unsubscribe from the event.
obs |> Observable.add(fun x -> printfn "C: %d" x)

// Now add a subscriber that only does positive numbers and transforms
// the numbers into another type, here a string.
let unsubD =
    obs |> Observable.choose (fun int1 ->
             if int1 >= 0 then None else Some(int1.ToString()))
        |> Observable.subscribe(fun string1 -> printfn "D: %s" string1)

let unsubE =
    obs |> Observable.filter (fun int1 -> int1 >= 0)
        |> Observable.subscribe(fun int1 -> printfn "E: %d" int1)

let unsubF =
    obs |> Observable.map (fun int1 -> int1.ToString())
        |> Observable.subscribe (fun string1 -> printfn "F: %s" string1)

Plattformen

Windows 7, Windows Vista SP2, Windows XP SP3, Windows XP x64 SP2, Windows Server 2008 R2, Windows Server 2008 SP2, Windows Server 2003 SP2

Versionsinformationen

F#-Runtime

Unterstützt in: 2.0, 4.0

Silverlight

Unterstützt in: 3

Siehe auch

Weitere Ressourcen

Microsoft.FSharp.Control-Namespace (F#)

Änderungsprotokoll

Datum	Versionsgeschichte	Grund
Oktober 2010	Codebeispiel hinzugefügt.	Informationsergänzung.