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)。

請參閱

參考

Microsoft.FSharp.Control 命名空間 (F#)