¿Existe una forma más elegante de combinar observables cuando el tipo de devolución no es importante?

Question

Tengo un modelo de vista ReactiveUI-like. Tiene varias propiedades de diferentes tipos que activan los eventos NotifyPropertyChanged y quiero suscribir un método que se invocará cuando se active alguno, pero no estoy interesado en los valores reales.

Mi código actual es un poco feo (debido a true opaco selecciona). ¿Hay alguna manera de expresar esto que muestre la intención de cuidar solo cuando ocurre el evento?

this.ObservableForProperty(m => m.PropertyOne) 
     .Select(_ => true) 
     .Merge(this.ObservableForProperty(m => m.PropertyTwo).Select(_ => true)) 
    .Subscribe(...) 

estoy fusión de alrededor de 8 propiedades, por lo que es más feo que se muestra.

Answer 1

Dado que esto se parece a ReactiveUI, cómo sobre el uso del operador WhenAny:

this.WhenAny(x => x.PropertyOne, x => x.PropertyTwo, (p1, p2) => Unit.Default) 
    .Subscribe(x => /* ... */); 

En general, sin embargo, si Combinando observaciones arbitrarias, también podría escribir esto un poco más claramente utilizando el método sin extensión:

Observable.Merge(
    this.ObservableForProperty(x => x.PropertyOne).Select(_ => Unit.Default), 
    this.ObservableForProperty(x => x.PropertyTwo).Select(_ => Unit.Default), 
    this.ObservableForProperty(x => x.PropertyThree).Select(_ => Unit.Default) 
).Subscribe(x => /* ... */); 

Además, si usted está suscribiendo a todas las propiedades de un ReactiveObject, probablemente es mejor usar simplemente:

this.Changed.Subscribe(x => /* ... */); 

Answer 2

que podría hacer que un método de extensión para hacer el intento más claro:

public static IObservable<bool> IgnoreValue<T>(this IObservable<T> source) 
{ 
    return source.Select(_ => true); 
} 

... 

this.ObservableForProperty(m => m.PropertyOne).IgnoreValue() 
.Merge(this.ObservableForProperty(m => m.PropertyTwo).IgnoreValue()) 
.Subscribe(..);