Control.Observable — Moduł (F#)

Podstawowe operacje na pierwszej klasy zdarzeń i inne obiekty dostrzegalnych.

Ścieżka obszaru nazw/modułu: Microsoft.FSharp.Control

Zestaw: FSharp.Core (w FSharp.Core.dll)

module Observable

Wartości

Wartość	Opis
Dodawanie : ('T -> unit) -> IObservable<'T> -> unit	Tworzy, które trwale subskrybuje danego dostrzegalne i która wywołuje funkcję danej obserwacji każdego obserwatora.
Wybierz : ('T -> 'U option) -> IObservable<'T> -> IObservable<'U>	Zwraca zauważalny, który wybiera rzut uwagi od źródła przy użyciu danej funkcji.Zwracany obiekt wyzwoli obserwacji, dla których rozdzielacz zwraca Somewartości.Zwracany obiekt również propaguje wszystkie błędy wynikające ze źródła i kończy po zakończeniu źródła.
Filtr : ('T -> bool) -> IObservable<'T> -> IObservable<'T>	Zwraca zauważalny, który filtruje obserwacje źródła przez daną funkcję.Możliwe do zaobserwowania zobaczy tylko tych uwag, dla których predykat zwraca true.Predykat jest wykonywana raz dla każdego obserwatora subskrybowany.Zwracany obiekt również propaguje błąd uwag wynikających ze źródła i kończy po zakończeniu źródła.
Mapa : ('T -> 'U) -> IObservable<'T> -> IObservable<'U>	Zwraca zauważalny, który przekształca obserwacje źródła przez daną funkcję.Funkcja transformacji jest wykonywany raz dla każdego obserwatora subskrybowany.Zwracany obiekt również propaguje błąd uwag wynikających ze źródła i kończy po zakończeniu źródła.
korespondencji seryjnej : IObservable<'T> -> IObservable<'T> -> IObservable<'T>	Zwraca zauważalny obserwacji scalone ze źródeł.Zwracany obiekt propaguje sukcesu i błędu wartości wynikające z albo źródło i kończy po zakończeniu obu źródeł.
potrzeby : IObservable<'T> -> IObservable<'T * 'T>	Zwraca nowy dostrzegalne, która wyzwala na drugim i kolejnych triggerings z wejściowych dostrzegalne.N-ty wyzwolenie wprowadzania dostrzegalne przekazuje argumenty z n 1th i n-ty wyzwolenie jako parę.Argument przekazany do wyzwalania 1th n odbywa się ukryte stanu wewnętrznego aż n-ty wyzwolenie występuje.
partycja : ('T -> bool) -> IObservable<'T> -> IObservable<'T> * IObservable<'T>	Zwraca dwa observables, które partycje obserwacje źródła przez daną funkcję.Pierwszy wyzwoli obserwacji dla tych wartości, dla których predykat zwraca true.Drugi wyzwoli obserwacji dla tych wartości, w którym zwraca predykat false.Predykat jest wykonywana raz dla każdego obserwatora subskrybowany.Zarówno również propagować wszystkie obserwacje błędów wynikających ze źródła i każdy kończy się po zakończeniu źródła.
skanowanie : ('U -> 'T -> 'U) -> 'U -> IObservable<'T> -> IObservable<'T>	Zwraca zauważalny, które dla każdego obserwatora przydziela elementu członkowskiego i dotyczy dana funkcja kumulowanych kolejnych wartości wynikające z danych wejściowych.Zwracany obiekt wyzwoli obserwacji dla każdej wartości kalkulowanej Państwa, z wyłączeniem wartości początkowe.Zwracany obiekt propaguje wszystkie błędy wynikające ze źródła i kończy po zakończeniu źródła.
Podziel : ('T -> Choice<'U1,'U2>) -> IObservable<'T> -> IObservable<'U1> * IObservable<'U2>	Zwraca dwa observables, które podzielić obserwacje źródła przez daną funkcję.Pierwszy wyzwoli obserwacji, dla których rozdzielacz zwraca Choice1Of2.Drugi wyzwoli obserwacji y do rozdzielacza zwraca Choice2Of2.Rozdzielacz jest wykonywana raz dla każdego obserwatora subskrybowany.Zarówno również propagować błąd uwag wynikających ze źródła i każdy kończy się po zakończeniu źródła.
Subskrybuj : ('T -> unit) -> IObservable<'T> -> IDisposable	Tworzy które subskrybuje danego dostrzegalne i która wywołuje funkcję danej obserwacji każdego obserwatora.

Przykład

Poniższy przykład kodu pokazuje, jak używać observables.ObserverSource Klasy zdefiniowane w tym przykładzie jest klasa wielokrotnego użytku ogólnego przeznaczenia można użyć jako źródła zdarzeń dostrzegalnych.Przykłady użycia niektórych funkcji w tym module są tu; Funkcje, które nie są wykazane w tym miejscu można znaleźć przykłady kodu w Control.Event — Moduł (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)

Platformy

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

Informacje o wersji

F# Core wersji biblioteki

Obsługiwane: 2.0, 4.0, przenośne

Zobacz też

Informacje

Microsoft.FSharp.Control — Przestrzeń nazw (F#)