Módulo de Control.Observable (F#)

Operações básicas no evento de primeira classe e outros objetos observáveis.

Caminho do namespace/módulo: Microsoft.FSharp.Control

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

module Observable

Valores

Valor	Descrição
Adicionar : ('T -> unit) -> IObservable<'T> -> unit	Cria um observador permanentemente que assina o observável determinada e que chama a função determinada para cada observação.
Escolha : ('T -> 'U option) -> IObservable<'T> -> IObservable<'U>	Retorna um observável que escolhe uma projeção de observações da fonte usando a função determinada. O objeto retornado irá disparar Observações para o qual o divisor retorna um Somevalor. O objeto retornado também propaga todos os erros decorrentes da origem e é concluída quando a origem é concluída.
filtro : ('T -> bool) -> IObservable<'T> -> IObservable<'T>	Retorna um observável que filtra as observações da origem por determinada função. O observável verá apenas as observações para o qual o predicado retorna true. O predicado é executado uma vez para cada observador inscrito. O objeto retornado também propaga as observações de erro decorrente da origem e é concluída quando a origem é concluída.
mapa : ('T -> 'U) -> IObservable<'T> -> IObservable<'U>	Retorna um observável que transforma as observações da origem por determinada função. A função de transformação é executada uma vez para cada observador inscrito. O objeto retornado também propaga as observações de erro decorrente da origem e é concluída quando a origem é concluída.
mesclagem : IObservable<'T> -> IObservable<'T> -> IObservable<'T>	Retorna um observável para as observações mescladas de origens. O objeto retornado propaga o sucesso e o erro valores decorrentes de qualquer origem e é concluído quando tem concluído a ambas as fontes.
Pairwise : IObservable<'T> -> IObservable<'T * 'T>	Retorna um novo observável que dispara a triggerings segundos e subseqüentes da entrada observáveis. Enésimo disparo da entrada observável passa os argumentos do N-1th e disparo enésimo como um par. O argumento passado para o disparo de N-1th é mantido em estado interno oculto até que o enésimo disparo ocorre.
partição : ('T -> bool) -> IObservable<'T> -> IObservable<'T> * IObservable<'T>	Retorna dois observables que as observações da fonte de partição por determinada função. O primeiro acionará Observações para os valores para o qual o predicado retorna true. O segundo disparará Observações para os valores que o predicado retorna false. O predicado é executado uma vez para cada observador inscrito. Ambos também propagam a todas as observações de erro decorrente da fonte e a cada conclusão, quando a origem é concluída.
varredura : ('U -> 'T -> 'U) -> 'U -> IObservable<'T> -> IObservable<'T>	Retorna um observável que, para cada observador aloca um item do estado e aplica a determinada função acumulando sucessivos valores decorrentes da entrada. O objeto retornado irá disparar Observações para cada valor de estado computada, excluindo o valor inicial. O objeto retornado propaga todos os erros decorrentes da origem e é concluída quando a origem é concluída.
divisão : ('T -> Choice<'U1,'U2>) -> IObservable<'T> -> IObservable<'U1> * IObservable<'U2>	Retorna dois observables que dividir as observações da fonte de determinada função. O primeiro acionará Observações para o qual o divisor retorna Choice1Of2. O segundo disparará observações y para que o divisor retorna Choice2Of2. O divisor é executado uma vez para cada observador inscrito. Ambos também propagam observações de erro decorrente da fonte e a cada conclusão, quando a origem é concluída.
Inscrever-se : ('T -> unit) -> IObservable<'T> -> IDisposable	Cria um observador que assina o observável determinada e que chama a função determinada para cada observação.

Exemplo

O exemplo de código a seguir mostra como usar o observables. O ObserverSource classe definida neste exemplo é uma classe reutilizável de uso geral que pode ser usado como uma fonte de eventos observáveis. Exemplos do uso de algumas das funções neste módulo são mostrados aqui; para funções que não são demonstradas aqui, você pode consultar exemplos de código Módulo de 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 7, SP2 do Windows Vista, Windows XP SP3, Windows XP Professional x64 SP2, Windows Server 2008 R2, Windows Server 2008 SP2, Windows Server 2003 SP2

Informações sobre versão

O tempo de execução F#

Compatível com: 2.0, 4.0

Silverlight

Compatível com: 3

Consulte também

Referência

Microsoft.FSharp.Control Namespace (F#)

Histórico de alterações

Date	History	Motivo
Outubro de 2010	Exemplo de código adicionado.	Aprimoramento de informações.