public void Raise_PropertyChangeExtension_EventFired()
{
var raiser = new NotifySubject();
string changed = string.Empty;
raiser.PropertyChanged += (sender, e) => { changed = e.PropertyName; };
raiser.D = 3m;
Assert.That(changed, Is.EqualTo("D"));
}
public void Notify_Changed_NoValues()
{
var subject = new NotifySubject();
string propertyChangedName = null;
subject.PropertyChanged += (sender, args) => propertyChangedName = args.PropertyName;
subject.S = "2";
Assert.That(propertyChangedName, Is.EqualTo("S"));
subject.I = 2;
Assert.That(propertyChangedName, Is.EqualTo("I"));
}
public void Observing_PropertyChanging_Changes()
{
var subject = new NotifySubject();
string propertyChangingName = null;
using (subject.Observing((sender, e) => propertyChangingName = e.PropertyName))
{
subject.S = "2";
}
// this happens after the handler has been unregistered
subject.I = 2;
Assert.That(propertyChangingName, Is.EqualTo("S"));
}
public IObservable <SetAddEvent <T> > ObserveAdd()
{
if (isDisposed)
{
return(Observable.Empty <SetAddEvent <T> >());
}
return(setAdd ?? (setAdd = new NotifySubject <SetAddEvent <T> >(observer =>
{
foreach (var el in this)
{
observer.OnNext(new SetAddEvent <T>(el));
}
})));
}
private void Subscribe()
{
isSubscribed = true;
subjectAdd = new NotifySubject <SetAddEvent <T> >(observer =>
{
foreach (var el in elements)
{
observer.OnNext(new SetAddEvent <T>(el));
}
});
subjectRemove = new NotifySubject <SetRemoveEvent <T> >(null);
subjectClear = new NotifySubject <Unit>(null);
superAdd = super.ObserveAdd().Subscribe(@event =>
{
if (predicate(@event.Value))
{
elements.Add(@event.Value);
subjectAdd.OnNext(@event);
}
});
superRemove = super.ObserveRemove().Subscribe(@event =>
{
if (predicate(@event.Value))
{
elements.Remove(@event.Value);
subjectRemove.OnNext(@event);
}
});
superClear = super.ObserveReset().Subscribe(@event =>
{
elements.Clear();
subjectClear.OnNext(@event);
});
lastDisposed = subjectAdd.LastDisposed.Subscribe(TryUnsubscribe);
lastDisposed2 = subjectRemove.LastDisposed.Subscribe(TryUnsubscribe);
lastDisposed3 = subjectClear.LastDisposed.Subscribe(TryUnsubscribe);
}
public void Notify_HowToCancel_OnProperlyImplementedProperties()
{
var subject = new NotifySubject {
I = 1, F = 2.0f
};
subject.PropertyChanging += (sender, args) =>
{
var cancellable = args as ICancelEventArgs;
if (cancellable != null)
{
cancellable.Cancel();
}
};
subject.I = 2;
// I does not obbey cancellation rules
Assert.That(subject.I, Is.EqualTo(2));
subject.F = 3.0f;
// F obbeys cancellation rules and since it is being, regardless, cancelled
// the new value will never be set
Assert.That(subject.F, Is.EqualTo(2.0f));
}
public void Notify_Changing_Values()
{
var subject = new NotifySubject {
I = 1
};
string propertyChangingName = null;
int oldValue = 0, newValue = 0;
subject.PropertyChanging += (sender, args) =>
{
// nasty casting due to inflexibility of generics
var extended = (PropertyValueChangingEventArgs <int>)args;
propertyChangingName = extended.PropertyName;
oldValue = extended.OldValue;
newValue = extended.NewValue;
};
subject.I = 2;
Assert.That(propertyChangingName, Is.EqualTo("I"));
Assert.That(oldValue, Is.EqualTo(1));
Assert.That(newValue, Is.EqualTo(2));
}
