Control.Observable – modul (F#)
Základní operace na první třídy událostí a další objekty pozorovatelné.
Cesta k oboru názvů nebo modul: Microsoft.FSharp.Control
Sestavení: FSharp.Core (v FSharp.Core.dll)
module Observable
Hodnoty
Value |
Description |
|---|---|
Přidat : ('T -> unit) -> IObservable<'T> -> unit |
Vytvoří pozorovatele, které trvale přihlásí k danému lze zobrazit a která volá danou funkci pro každé z pozorování. |
Zvolte : ('T -> 'U option) -> IObservable<'T> -> IObservable<'U> |
Vrátí lze zobrazit, které zvolí ze zdroje pomocí funkce dané průmět pozorování.Spustí vráceného objektu pozorování, které vrátí příčky Somehodnotu.Vrácený objekt také šíří všechny chyby vyplývající ze zdroje a dokončí po dokončení zdroje. |
Filtr : ('T -> bool) -> IObservable<'T> -> IObservable<'T> |
Vrátí lze zobrazit, který filtruje pozorování zdroje dané funkce.Lze zobrazit se zobrazí pouze poznámky, které vrátí predikátu true.Predikátu proveden jednou pro každý pozorovatel upsaného.Vrácený objekt také rozšíří pozorování chyby vyplývající ze zdroje a dokončí po dokončení zdroje. |
Mapa : ('T -> 'U) -> IObservable<'T> -> IObservable<'U> |
Vrátí lze zobrazit, který transformuje pozorování zdroje dané funkce.Transformační funkce je pro každého pozorovatele upsaného proveden jednou.Vrácený objekt také rozšíří pozorování chyby vyplývající ze zdroje a dokončí po dokončení zdroje. |
sloučení : IObservable<'T> -> IObservable<'T> -> IObservable<'T> |
Vrátí lze zobrazit pro sloučené pozorování ze zdrojů.Vráceného objektu rozšíří úspěch a chybové hodnoty vyplývající z obou zdrojů a dokončení při dokončení obou zdrojů. |
ukládání : IObservable<'T> -> IObservable<'T * 'T> |
Vrátí nové lze zobrazit, která spustí druhý a následné triggerings vstupní lze zobrazit.N-tý aktivaci lze zobrazit vstupní předá argumenty n 1th a n-tý aktivaci jako pár.Argument předaný do n 1th aktivaci je udržována v skryté vnitřního stavu, dokud nedojde k aktivaci n-tý. |
oddíl : ('T -> bool) -> IObservable<'T> -> IObservable<'T> * IObservable<'T> |
Dva observables, které oddíly pozorování zdroje dané funkce vrátí.Spustí první pozorování pro tyto hodnoty, které vrátí predikátu true.Spustí druhý pozorování těchto hodnot, kde predikátu vrátí false.Predikátu proveden jednou pro každý pozorovatel upsaného.Obě rozšířit také všechny chyby připomínky vyplývající ze zdroje a každý dokončí po dokončení zdroje. |
skenování : ('U -> 'T -> 'U) -> 'U -> IObservable<'T> -> IObservable<'T> |
Vrátí lze zobrazit, které pro každý pozorovatel přiděluje položce státu a použije dané accumulating funkce vyplývající ze vstupu po sobě následujících hodnot.Vrácený objekt aktivují pozorování pro každou hodnotu vypočítaný státu s výjimkou počáteční hodnota.Vrácený objekt šíří všechny chyby vyplývající ze zdroje a dokončí po dokončení zdroje. |
rozdělit : ('T -> Choice<'U1,'U2>) -> IObservable<'T> -> IObservable<'U1> * IObservable<'U2> |
Vrátí dvěma observables, které dané funkce, rozdělit pozorování zdroje.Spustí první připomínky, které vrátí příčky Choice1Of2.Spustí druhý pozorování y pro které vrátí příčky Choice2Of2.Příčky pro každého pozorovatele upsaného jednou spuštěn.Oba také rozšířit pozorování chyby vyplývající ze zdroje a každý dokončí po dokončení zdroje. |
přihlášení odběru : ('T -> unit) -> IObservable<'T> -> IDisposable |
Vytvoří pozorovatel lze zobrazit dané odebírá a která volá danou funkci pro každé z pozorování. |
Příklad
Následující příklad kódu ukazuje, jak používat observables.ObserverSource Třídy definované v tomto příkladu je univerzální opakovaně použitelné třídy, můžete použít jako zdroj událostí pozorovatelné.Příklady použití některých funkcí v tomto modulu jsou zobrazeny zde; pro funkce, které zde nejsou prokázána, můžete odkazovat na příklady kódu v 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)
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é