c# - Rx-¿Puedo/debería reemplazar eventos.NET con Observables?

events system.reactive

Question

Teniendo en cuenta los beneficios de los eventos compostables ofrecidos por el marco de Reactive Extensions (Rx) , me pregunto si mis clases deberían dejar de presionar a los eventos .NET, y en su lugar exponer Rx observables.

Por ejemplo, tome la siguiente clase usando eventos .NET estándar:

public class Foo
{
private int progress;
public event EventHandler ProgressChanged;
public int Progress
{
get { return this.progress; }
set
{
if (this.progress != value)
{
this.progress = value;
// Raise the event while checking for no subscribers and preventing unsubscription race condition.
var progressChanged = this.ProgressChanged;
if (progressChanged != null)
{
progressChanged(this, new EventArgs());
}
}
}
}
}

Gran cantidad de fontanería monótona.

En su lugar, esta clase podría usar algún tipo de observable para reemplazar esta funcionalidad:

public class Foo
{
public Foo()
{
this.Progress = some new observable;
}
public IObservable<int> Progress { get; private set; }
}

Mucho menos fontanería La intención ya no está oscurecida por los detalles de fontanería. Esto parece beneficioso.

Mis preguntas para usted, la gente de StackOverflow es:

1. ¿Sería bueno / valioso reemplazar los eventos .NET estándar con los valores IObservable <T>?
2. Si tuviera que usar un observable, ¿qué tipo usaría aquí? Obviamente tengo que pasarle valores (por ejemplo, Progress.UpdateValue (...) o algo así).

Answer 1

Además del hecho de que tu código de evento podría ser más exclusivo:

 public event EventHandler ProgressChanged = delegate {};
...
set {
...
// no need for null check anymore
ProgressChanged(this, new EventArgs());
}

Creo que al cambiar a Observable<int> simplemente está trasladando la complejidad del llamado al llamante. ¿Qué pasa si solo quiero leer el int?

-Oisin

Answer 2

Lo mantendré corto y simple:

1. sí
2. BehaviorSubject

:)

Answer 3

No recomiendo administrar su propia lista de suscriptores cuando hay temas integrados que pueden hacer eso por usted. También elimina la necesidad de llevar su propia copia mutable de T.

A continuación está mi versión (sin comentarios) de su solución:

public class Observable<T> : IObservable<T>, INotifyPropertyChanged
{
private readonly BehaviorSubject<T> values;
private PropertyChangedEventHandler propertyChanged;
public Observable() : this(default(T))
{
}
public Observable(T initalValue)
{
this.values = new BehaviorSubject<T>(initalValue);
values.DistinctUntilChanged().Subscribe(FirePropertyChanged);
}
public T Value
{
get { return this.values.First(); }
set { values.OnNext(value); }
}
private void FirePropertyChanged(T value)
{
var handler = this.propertyChanged;
if (handler != null)
handler(this, new PropertyChangedEventArgs("Value"));
}
public override string ToString()
{
return value != null ? value.ToString() : "Observable<" + typeof(T).Name + "> with null value.";
}
public static implicit operator T(Observable<T> input)
{
return input.Value;
}
public IDisposable Subscribe(IObserver<T> observer)
{
return values.Subscribe(observer);
}
event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged
{
add { this.propertyChanged += value; }
remove { this.propertyChanged -= value; }
}
}

Answer 4

Ok chicos, viendo que creo que al menos vale la pena probar esto, y viendo cómo el Subject <T> de RX no es exactamente lo que estoy buscando, he creado un nuevo observable que se ajusta a mis necesidades:

• Implementa IObservable <T>
• Implementa INotifyPropertyChange para que funcione con el enlace WPF / Silverlight.
• Proporciona una semántica fácil de obtener / establecer.

Llamo a la clase Observable <T>.

Declaración:

/// <summary>
/// Represents a value whose changes can be observed.
/// </summary>
/// <typeparam name="T">The type of value.</typeparam>
public class Observable<T> : IObservable<T>, INotifyPropertyChanged
{
private T value;
private readonly List<AnonymousObserver> observers = new List<AnonymousObserver>(2);
private PropertyChangedEventHandler propertyChanged;
/// <summary>
/// Constructs a new observable with a default value.
/// </summary>
public Observable()
{
}
public Observable(T initalValue)
{
this.value = initialValue;
}
/// <summary>
/// Gets the underlying value of the observable.
/// </summary>
public T Value
{
get { return this.value; }
set
{
var valueHasChanged = !EqualityComparer<T>.Default.Equals(this.value, value);
this.value = value;
// Notify the observers of the value.
this.observers
.Select(o => o.Observer)
.Where(o => o != null)
.Do(o => o.OnNext(value))
.Run();
// For INotifyPropertyChange support, useful in WPF and Silverlight.
if (valueHasChanged && propertyChanged != null)
{
propertyChanged(this, new PropertyChangedEventArgs("Value"));
}
}
}
/// <summary>
/// Converts the observable to a string. If the value isn''t null, this will return
/// the value string.
/// </summary>
/// <returns>The value .ToString''d, or the default string value of the observable class.</returns>
public override string ToString()
{
return value != null ? value.ToString() : "Observable<" + typeof(T).Name + "> with null value.";
}
/// <summary>
/// Implicitly converts an Observable to its underlying value.
/// </summary>
/// <param name="input">The observable.</param>
/// <returns>The observable''s value.</returns>
public static implicit operator T(Observable<T> input)
{
return input.Value;
}
/// <summary>
/// Subscribes to changes in the observable.
/// </summary>
/// <param name="observer">The subscriber.</param>
/// <returns>A disposable object. When disposed, the observer will stop receiving events.</returns>
public IDisposable Subscribe(IObserver<T> observer)
{
var disposableObserver = new AnonymousObserver(observer);
this.observers.Add(disposableObserver);
return disposableObserver;
}
event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged
{
add { this.propertyChanged += value; }
remove { this.propertyChanged -= value; }
}
class AnonymousObserver : IDisposable
{
public IObserver<T> Observer { get; private set; }
public AnonymousObserver(IObserver<T> observer)
{
this.Observer = observer;
}
public void Dispose()
{
this.Observer = null;
}
}
}

Uso:

El consumo es agradable y fácil. ¡Sin plomería!

public class Foo
{
public Foo()
{
Progress = new Observable<T>();
}
public Observable<T> Progress { get; private set; }
}

El uso es simple:

// Getting the value works just like normal, thanks to implicit conversion.
int someValue = foo.Progress;
// Setting the value is easy, too:
foo.Progress.Value = 42;

Puede enlazar datos en WPF o Silverlight, solo enlazar a la propiedad Value.

<ProgressBar Value={Binding Progress.Value} />

Lo más importante es que puedes componer, filtrar, proyectar y hacer todas las cosas sexy que RX te permite hacer con IObservables:

Eventos de filtrado:

foo.Progress
.Where(val => val == 100)
.Subscribe(_ => MyProgressFinishedHandler());

Anulación de suscripción automática luego de N invocaciones:

foo.Progress
.Take(1)
.Subscribe(_ => OnProgressChangedOnce());

Componer eventos:

// Pretend we have an IObservable<bool> called IsClosed:
foo.Progress
.TakeUntil(IsClosed.Where(v => v == true))
.Subscribe(_ => ProgressChangedWithWindowOpened());

¡Cosas ingeniosas!

Answer 5

Para el n. ° 2, la forma más directa es a través de un Asunto:

Subject<int> _Progress;
IObservable<int> Progress {
get { return _Progress; }
}
private void setProgress(int new_value) {
_Progress.OnNext(new_value);
}
private void wereDoneWithWorking() {
_Progress.OnCompleted();
}
private void somethingBadHappened(Exception ex) {
_Progress.OnError(ex);
}

Con esto, ahora su "Progreso" no solo puede notificar cuándo ha cambiado el progreso, sino cuándo se ha completado la operación y si fue exitoso. Tenga en cuenta, sin embargo, que una vez que un IObservable se ha completado a través de OnCompleted o OnError, está "muerto"; no puede publicar nada más.