Control.Observable 模組 (F#)
第一級事件和其他可預見物件上的基本作業。
**命名空間/模組路徑：**Microsoft.FSharp.Control
組件：FSharp.Core (在 FSharp.Core.dll 中)
module Observable
值
值 |
描述 |
|---|---|
新增 : ('T -> unit) -> IObservable<'T> -> unit |
建立觀察器，這個觀察器會永久訂閱指定的可預見值，以及呼叫每個觀測之指定的函式。 |
choose : ('T -> 'U option) -> IObservable<'T> -> IObservable<'U> |
傳回可預見值，這個可預見值會使用指定的函式從來源中選擇觀測投影。 傳回的物件將會觸發讓分隔器傳回 Some值的觀測。 傳回的物件也會傳播從來源引發的所有錯誤，並且於來源完成時完成。 |
filter : ('T -> bool) -> IObservable<'T> -> IObservable<'T> |
傳回可預見值，這個可預見值會透過指定的函式來篩選來源的觀測。 可預見值只會看到述詞傳回 true 的觀測。 每一個已訂閱之觀察器的述詞都會執行一次。 傳回的物件也會傳播自來源引發的錯誤觀測，並且於來源完成時完成。 |
map : ('T -> 'U) -> IObservable<'T> -> IObservable<'U> |
傳回可預見值，這個可預見值會透過指定的函式來轉換來源的觀測。 每個已訂閱的觀察器都會執行轉換函式一次。 傳回的物件也會傳播自來源引發的錯誤觀測，並且於來源完成時完成。 |
merge : IObservable<'T> -> IObservable<'T> -> IObservable<'T> |
對來源中的合併觀測傳回可預見值。 傳回的物件會傳播從任一來源引發的成功和錯誤值，並於兩個來源皆已完成時完成。 |
pairwise : IObservable<'T> -> IObservable<'T * 'T> |
傳回新的可預見值，這個可預見值會在輸入可預見值的第二個和後續觸發動作時觸發。 輸入可預見值的第 N 個觸發動作，會從成對的第 N-1 個和第 N 個觸發動作來傳遞引數。 傳遞給第 N-1 個觸發動作的引數會保留在隱藏的內部狀態中，直到第 N 個觸發動作發生為止。 |
partition : ('T -> bool) -> IObservable<'T> -> IObservable<'T> * IObservable<'T> |
傳回兩個可預見值，這兩個可預見值會透過指定的函式來分割來源的觀測。 第一個可預見值會針對讓述詞傳回 true 的值觸發觀測。 第二個可預見值則會針對讓述詞傳回 false 的值觸發觀測。 每一個已訂閱之觀察器的述詞都會執行一次。 兩者也會傳播自來源引發的錯誤觀測，而且來源完成時這兩者也都完成。 |
scan : ('U -> 'T -> 'U) -> 'U -> IObservable<'T> -> IObservable<'T> |
傳回可預見值，針對每一個觀察器，配置狀態項目並將指定的累積函式套用到從輸入引發的後續值。 傳回的物件將會針對每一個計算的狀態值 (不包含初始值) 觸發觀測。 傳回的物件會傳播從來源引發的所有錯誤，並且於來源完成時完成。 |
split : ('T -> Choice<'U1,'U2>) -> IObservable<'T> -> IObservable<'U1> * IObservable<'U2> |
傳回兩個可預見值，這兩個可預見值會透過指定的函式來分割來源的觀測。 第一個可預見值將會觸發可讓分隔器傳回 Choice1Of2 的觀測。 第二個可預見值將會觸發讓分隔器傳回 Choice2Of2 的觀測 y。 每個已訂閱之觀察器的分隔器都會執行一次。 兩者也會傳播自來源引發的錯誤觀測，而且來源完成時這兩者也都完成。 |
subscribe : ('T -> unit) -> IObservable<'T> -> IDisposable |
建立觀察器，這個觀察器會訂閱指定的可預見值，以及呼叫每個觀測之指定的函式。 |
範例
下列程式碼範例示範如何使用可預見值。 在此範例中定義的 ObserverSource 類別是可重複使用的通用類別，您可以當做可預見事件的來源使用。 這裡示範某些使用此模組中的某些函式；如為本處未示範的函式，您可以參考 Control.Event 模組 (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)
平台
Windows 8 中， Windows 7， Windows Server 2012 上， Windows Server 2008 R2
版本資訊
F# 核心程式庫版本
支援版本:2.0， 4.0，可攜式執行檔 (PE)。