reactive and inotifyproperties.

HasObservableProperties.cs

using System.ComponentModel;
using System.Linq.Expressions;
using System;

using System.Reactive.Linq;
using System.Reactive;

namespace Foo
{
	public abstract class HasObservableProperties: INotifyPropertyChanged
	{
		public static System.Reflection.MemberInfo MemberFrom<TValue>(Expression<Func<TValue>> expression)
		{
			var memberExpression = expression.Body as MemberExpression ?? ((UnaryExpression) expression.Body).Operand as MemberExpression;
			if(memberExpression == null)
				throw new ArgumentException("Invalid expression (not a member expression): " + expression);
			return memberExpression.Member;
		}

		public event PropertyChangedEventHandler PropertyChanged;
		protected void NotifyPropertyChanged(string propertyName)
		{
			var handler = PropertyChanged;
			if(handler != null)
				handler(this, new PropertyChangedEventArgs(propertyName));
		}
		protected void NotifyPropertyChanged<T>(Expression<Func<T>> expression) { NotifyPropertyChanged(MemberFrom(expression).Name); }

		protected bool SetAndNotify<T>(ref T field, T value, Expression<Func<T>> expression)
		{
			if(System.Collections.Generic.EqualityComparer<T>.Default.Equals(field, value))
				return false;
			field = value;
			NotifyPropertyChanged(expression);
			return true;
		}

		public IObservable<T> PropertyAsObservable<T>(Expression<Func<T>> propExpr)
		{
			var property   = MemberFrom(propExpr);
			Func<T> getter = propExpr.Compile();
			return PropertyChangedEventsAsObservable()
				.Where(e => e.EventArgs.PropertyName == property.Name)
				.Select(e => getter())
				.StartWith(getter());
		}

		public IObservable<EventPattern<PropertyChangedEventArgs>> PropertyChangedEventsAsObservable()
		{
			return Observable.FromEventPattern<PropertyChangedEventHandler,PropertyChangedEventArgs>((h => PropertyChanged+=h), (h => PropertyChanged-=h));
		}
	}
}