Módulo Control.Observable (F#)

Operações básicas no evento da primeira classe e outros objetos perceptíveis.

Namespace/Module Path: Microsoft.FSharp.Control

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

module Observable

Valores

Valor	Descrição
adicione: ('T -> unit) -> IObservable<'T> -> unit	Cria um observador que assinem permanentemente para o observable determinado e que chama a função determinada para cada observação.
escolha: ('T -> 'U option) -> IObservable<'T> -> IObservable<'U>	Retorna um que observable escolha uma projeção das observações de origem usando a função especificados. O objeto retornado irá acionar as observações para o separador retorna um valor de Some. O objeto retornado também propaga todos os erros que ocorrem de origem e termina quando a fonte completa.
filtro: ('T -> bool) -> IObservable<'T> -> IObservable<'T>	Retorna um observable que filtra as observações de origem determinada pela função. O observable verá apenas as observações para que o predicado retorna true. o predicado é executado uma vez para cada observador assinado. As observações retornados de erro de se propaga de objeto também que ocorrem de origem e usa quando a fonte completa.
mapa: ('T -> 'U) -> IObservable<'T> -> IObservable<'U>	Retorna um observable que torna as observações de origem determinada pela função. A função de transformação é executada uma vez para cada observador assinado. As observações retornados de erro de se propaga de objeto também que ocorrem de origem e usa quando a fonte completa.
mesclagem: IObservable<'T> -> IObservable<'T> -> IObservable<'T>	Retorna um observable para as observações mescladas de fontes. O objeto retornado propaga o êxito e o erro ocorrer valor de uma ou outra fonte e termina quando ambas as fontes terminar.
por pares: IObservable<'T> -> IObservable<'T * 'T>	Retorna um novo observable que dispare em segundos e triggerings subseqüentes de observable de entrada. Nth disparar de observable de entrada passa os argumentos de N-1th e disparar Nth como um par. O argumento passado para disparar de N-1th é mantida no estado interno oculta até que Nth disparar ocorra.
: ('T -> bool) -> IObservable<'T> -> IObservable<'T> * IObservable<'T>departition	Retorna observables divide dois que as observações de origem determinada pela função. O primeiro irá acionar observações para esses valores para que o predicado retorna true. O segundo irá acionar observações para esses valores onde o predicado retorna false. o predicado é executado uma vez para cada observador assinado. Ambos também são propagadas todas as observações de erro que ocorrem de origem e cada um termina quando a fonte completa.
: ('U -> 'T -> 'U) -> 'U -> IObservable<'T> -> IObservable<'T>deverificação	Retorna um observable que, para cada observador, atribua um item de estado e aplica a função acúmulo de dada a valores sucessivos que ocorrem de entrada. O objeto retornado irá acionar observações para cada valor calculado de estado, excluindo o valor inicial. O objeto retornado propaga todos os erros que ocorrem de origem e termina quando a fonte completa.
: ('T -> Choice<'U1,'U2>) -> IObservable<'T> -> IObservable<'U1> * IObservable<'U2>dedivisão	Retorna observables divide dois que as observações de origem determinada pela função. O primeiro irá acionar as observações para o separador retorna Choice1Of2. O segundo irá acionar as observações y para o separador retorna Choice2Of2. o separador é executado uma vez para cada observador assinado. Ambos também as observações de erro que ocorrem de bolha de origem e de cada usa quando a fonte completa.
assinar: ('T -> unit) -> IObservable<'T> -> IDisposable	Cria um observador que assinem ao observable determinado e que chama a função determinada para cada observação.

Exemplo

O exemplo de código a seguir mostra como usar observables. A classe de ObserverSource definido em esse exemplo é uma classe reutilizável comumente usados que você possa usar como fonte de eventos perceptíveis. Exemplos de usar algumas das funções em este módulo são mostradas aqui; para funções que não são demonstradas aqui, você pode consultar os exemplos de código em Módulo 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)

Plataformas

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

Informações de Versão

Versões da biblioteca principal de F#

Suportado em: 2,0, 4,0, portáteis

Consulte também

Referência

Namespace Microsoft.FSharp.Control (F#)