using System;

namespace PropertyFacadeExample.ViewModel.Features
{
    public sealed class EditWorkingAttendanceViewModel : UXViewModel, ITracksChanges
    {
        public ChangeTracker ChangeTracker { get; } = new ChangeTracker();

        public EditWorkingAttendanceViewModel()
        {
            // Also includes change tracking support, which is optional.

            // DisposeWith registers the subscription with DisposableTracker.
            // This is necessary if you expect the domain model to live longer than the viewmodel.
            // When you close the viewmodel, call DisposableTracker.Dispose().
            //
            // You can dispose a PropertyFacade as many times as you need; this only disposes the underlying
            // subscription if one is present. Likewise you can re-use and re-dispose the tracker.
            //
            // Take care when creating and registering regular Rx subscriptions here in the constructor if you
            // intend to reuse the viewmodel after Dispose. If you dispose those subscriptions, they're gone.

            _adminA = this.PropFacade(vm => vm.AdminA).TrackChanges(this).DisposeWith(this);
            _adminB = this.PropFacade(vm => vm.AdminB).TrackChanges(this).DisposeWith(this);
            _nonSalary = this.PropFacade(vm => vm.NonSalary).TrackChanges(this).DisposeWith(this);
            _salary = this.PropFacade(vm => vm.Salary).TrackChanges(this).DisposeWith(this);
            _travel = this.PropFacade(vm => vm.Travel).TrackChanges(this).DisposeWith(this);
            _leave = this.PropFacade(vm => vm.Leave).TrackChanges(this).DisposeWith(this);
            _total = this.ReadOnlyPropFacade(vm => vm.Total).DisposeWith(this);
        }

        public decimal AdminA { get => _adminA.Value; set => _adminA.Value = value; }
        private readonly PropertyFacade<decimal> _adminA;

        public decimal AdminB { get => _adminB.Value; set => _adminB.Value = value; }
        private readonly PropertyFacade<decimal> _adminB;

        public decimal NonSalary { get => _nonSalary.Value; set => _nonSalary.Value = value;  }
        private readonly PropertyFacade<decimal> _nonSalary;

        public decimal Salary { get => _salary.Value; set => _salary.Value = value; }
        private readonly PropertyFacade<decimal> _salary;

        public decimal Travel { get => _travel.Value; set => _travel.Value = value; }
        private readonly PropertyFacade<decimal> _travel;

        public decimal Leave { get => _leave.Value; set => _leave.Value = value; }
        private readonly PropertyFacade<decimal> _leave;

        public decimal Total => _total.Value;
        private readonly ReadOnlyPropertyFacade<decimal> _total;

        public void Load(Domain.Models.WorkingAttendance model)
        {
            if (model is null)
            {
                throw new ArgumentNullException(nameof(model));
            }

            // PropertyFacade supports hot-swapping subscriptions.
            // If we want to treat the domain model as more-or-less discardable while keeping the viewmodel alive,
            // we can replace an older model with a new one.

            // We can also use ConvertOneWay or ConvertTwoWay extension methods from FacadeConverters.cs to convert value types
            // if the PropertyFacade type and the domain property type do not match. We may want to do this if we
            // need to "play nice" with a UI control that doesn't like the property on the domain.
            // To use this, place ConvertTwoWay() before ToProperty().

            model.AdminATime.ToProperty(this, _adminA);
            model.AdminBTime.ToProperty(this, _adminB);
            model.NonSalaryTime.ToProperty(this, _nonSalary);
            model.SalaryTime.ToProperty(this, _salary);
            model.TravelTime.ToProperty(this, _travel);
            model.LeaveTime.ToProperty(this, _leave);
            model.TotalTime.ToProperty(this, _total);
        }
    }
}


using PropertyFacadeExample.Domain;
using System;
using System.Collections.Generic;
using System.Reactive.Subjects;

namespace PropertyFacadeExample.ViewModel
{
    public sealed class ChangeTracker : IHasChanges
    {
        private readonly List<IHasChanges> _subjects = new List<IHasChanges>();

        public IReadOnlyValueObservable<bool> HasChanges { get; }
        private readonly BehaviorSubject<bool> _hasChangesSubject = new BehaviorSubject<bool>(default);

        private int TrueCount
        {
            get => _trueCount;
            set
            {
                if (value < 0)
                {
                    throw new ArgumentOutOfRangeException(nameof(value), $"Value must not be negative ({value}).");
                }

                _trueCount = value;
            }
        }
        private int _trueCount;

        public ChangeTracker()
        {
            HasChanges = _hasChangesSubject.ToCached();
        }

        public void Add(IHasChanges subject)
        {
            if (subject is null)
            {
                throw new ArgumentNullException(nameof(subject));
            }

            _subjects.Add(subject);

            bool init = true;

            subject.HasChanges.Subscribe(hasChanges =>
            {
                // Do not count no-changes when attaching to the observable.
                if (init && !hasChanges)
                {
                    return;
                }

                TrueCount += hasChanges ? 1 : -1;

                if (TrueCount == 0)
                {
                    _hasChangesSubject.OnNext(false);
                }
                else if (TrueCount == 1 && hasChanges)
                {
                    _hasChangesSubject.OnNext(true);
                }
            });

            init = false;
        }

        public void ResetValue()
        {
            foreach (var facade in _subjects)
            {
                facade.ResetValue();
            }
        }

        public void UpdateOriginalValue()
        {
            foreach (var facade in _subjects)
            {
                facade.UpdateOriginalValue();
            }
        }
    }
}
using System;
using System.Collections.Generic;

namespace PropertyFacadeExample.ViewModel
{
    /// <summary>
    /// Tracks a list of <see cref="IDisposable"/> objects. Prefer this over <see cref="CompositeDisposable"/>
    /// to avoid unnecessary allocations where no items need to be tracked.
    /// </summary>
    public sealed class DisposableTracker
    {
        private List<IDisposable> Disposables { get; set; }

        public void Add(IDisposable disposable)
        {
            if (disposable is null)
            {
                throw new ArgumentNullException(nameof(disposable));
            }

            if (Disposables is null)
            {
                Disposables = new List<IDisposable>();
            }

            Disposables.Add(disposable);
        }

        /// <summary>
        /// Disposes all tracked items and removes them from the list.
        /// </summary>
        public void Dispose()
        {
            if (!(Disposables is null))
            {
                foreach (var disposable in Disposables)
                {
                    disposable.Dispose();
                }

                Disposables.Clear();
            }
        }
    }
}
using System;
using System.Reactive.Linq;
using System.Reactive.Subjects;

namespace PropertyFacadeExample.ViewModel
{
    public abstract class OneWayFacadeConverter<TSource, TFacade>
    {
        public abstract TFacade SourceToFacade(TSource sourceValue);
    }

    public abstract class TwoWayFacadeConverter<TSource, TFacade> : OneWayFacadeConverter<TSource, TFacade>
    {
        public abstract TSource FacadeToSource(TFacade facadeValue);
    }

    public class ObservableFacadeConverterAdapter<TSource, TFacade> : IObservable<TFacade>
    {
        private readonly IObservable<TSource> _observable;
        private readonly OneWayFacadeConverter<TSource, TFacade> _converter;

        public IDisposable Subscribe(IObserver<TFacade> observer) =>
            _observable
            .Select(sourceValue => _converter.SourceToFacade(sourceValue))
            .Subscribe(observer);

        public ObservableFacadeConverterAdapter(IObservable<TSource> observable, OneWayFacadeConverter<TSource, TFacade> converter)
        {
            _observable = observable ?? throw new ArgumentNullException(nameof(observable));
            _converter = converter ?? throw new ArgumentNullException(nameof(converter));
        }
    }

    public class SubjectFacadeConverterAdapter<TSource, TFacade> : ObservableFacadeConverterAdapter<TSource, TFacade>, ISubject<TFacade>
    {
        private readonly ISubject<TSource> _subject;
        private readonly TwoWayFacadeConverter<TSource, TFacade> _converter;

        public void OnNext(TFacade value) => _subject.OnNext(_converter.FacadeToSource(value));

        public void OnError(Exception error) => _subject.OnError(error);

        public void OnCompleted() => _subject.OnCompleted();

        public SubjectFacadeConverterAdapter(ISubject<TSource> subject, TwoWayFacadeConverter<TSource, TFacade> converter)
            : base(subject, converter)
        {
            _subject = subject ?? throw new ArgumentNullException(nameof(subject));
            _converter = converter ?? throw new ArgumentNullException(nameof(converter));
        }
    }

    public static class FacadeConverterExtensions
    {
        private sealed class OneWayFuncConverter<TSource, TFacade> : OneWayFacadeConverter<TSource, TFacade>
        {
            private readonly Func<TSource, TFacade> _sourceToFacade;

            public override TFacade SourceToFacade(TSource sourceValue) => _sourceToFacade.Invoke(sourceValue);

            public OneWayFuncConverter(Func<TSource, TFacade> sourceToFacade)
            {
                _sourceToFacade = sourceToFacade ?? throw new ArgumentNullException(nameof(sourceToFacade));
            }
        }

        private sealed class TwoWayFuncConverter<TSource, TFacade> : TwoWayFacadeConverter<TSource, TFacade>
        {
            private readonly Func<TSource, TFacade> _sourceToFacade;
            private readonly Func<TFacade, TSource> _facadeToSource;

            public override TFacade SourceToFacade(TSource sourceValue) => _sourceToFacade.Invoke(sourceValue);

            public override TSource FacadeToSource(TFacade facadeValue) => _facadeToSource.Invoke(facadeValue);

            public TwoWayFuncConverter(Func<TSource, TFacade> sourceToFacade, Func<TFacade, TSource> facadeToSource)
            {
                _sourceToFacade = sourceToFacade ?? throw new ArgumentNullException(nameof(sourceToFacade));
                _facadeToSource = facadeToSource ?? throw new ArgumentNullException(nameof(facadeToSource));
            }
        }

        public static SubjectFacadeConverterAdapter<TSource, TFacade> ConvertTwoWay<TSource, TFacade>(
            this ISubject<TSource> source,
            Func<TSource, TFacade> sourceToFacade,
            Func<TFacade, TSource> facadeToSource) =>
                new SubjectFacadeConverterAdapter<TSource, TFacade>(
                    subject: source,
                    converter: new TwoWayFuncConverter<TSource, TFacade>(
                        sourceToFacade: sourceToFacade,
                        facadeToSource: facadeToSource));

        public static ObservableFacadeConverterAdapter<TSource, TFacade> ConvertOneWay<TSource, TFacade>(
            this IObservable<TSource> source,
            Func<TSource, TFacade> sourceToFacade) =>
                new ObservableFacadeConverterAdapter<TSource, TFacade>(
                    observable: source,
                    converter: new OneWayFuncConverter<TSource, TFacade>(
                        sourceToFacade: sourceToFacade));

        public static SubjectFacadeConverterAdapter<TSource, TFacade> ConvertTwoWay<TSource, TFacade>(
            this ISubject<TSource> source,
            TwoWayFacadeConverter<TSource, TFacade> converter) =>
                new SubjectFacadeConverterAdapter<TSource, TFacade>(source, converter);

        public static ObservableFacadeConverterAdapter<TSource, TFacade> ConvertOneWay<TSource, TFacade>(
            this IObservable<TSource> source,
            OneWayFacadeConverter<TSource, TFacade> converter) =>
                new ObservableFacadeConverterAdapter<TSource, TFacade>(source, converter);
    }
}

using PropertyFacadeExample.Domain;
using System;
using System.Reactive.Subjects;

namespace PropertyFacadeExample.ViewModel
{
    /// <summary>
    /// Encapsulates an observable or subject to provide an efficient way to get or set the latest value.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class FacadeValueCache<T> : IObservable<T>, IDisposable
    {
        private IDisposable _disposable;
        private IObservable<T> _observable;
        private Func<T> _getValueFunc;
        private Action<T> _setValueFunc;

        public bool CanSet => !(_setValueFunc is null);

        public bool HasObservable => !(_observable is null);

        public void Attach(IObservable<T> obs)
        {
            if (obs is null)
            {
                throw new ArgumentNullException(nameof(obs));
            }

            Dispose();

            if (obs is IReadOnlyValueObservable<T> iObsVal)
            {
                _observable = iObsVal;
                _getValueFunc = () => iObsVal.Value;
            }
            else if (obs is BehaviorSubject<T> behSub)
            {
                _observable = behSub;
                _getValueFunc = () => behSub.Value;
            }
            else
            {
                var cached = obs.ToCached();

                _observable = cached;
                _disposable = cached;

                _getValueFunc = () => cached.Value;
            }

            if (obs is IObserver<T> iSub)
            {
                _setValueFunc = value => iSub.OnNext(value);
            }
        }

        private void AssertHasObservable()
        {
            if (_observable is null)
            {
                throw new InvalidOperationException("No observable has been attached.");
            }
        }

        public T GetValue()
        {
            AssertHasObservable();

            return _getValueFunc.Invoke();
        }

        public void SetValue(T value)
        {
            AssertHasObservable();

            if (CanSet)
            {
                _setValueFunc.Invoke(value);
            }
            else
            {
                throw new InvalidOperationException("The observable does not implement IObserver.");
            }
        }

        public IDisposable Subscribe(IObserver<T> observer)
        {
            AssertHasObservable();

            return _observable.Subscribe(observer);
        }

        public void Dispose()
        {
            _disposable?.Dispose();
            _observable = null;
            _getValueFunc = null;
            _setValueFunc = null;
        }
    }
}

using PropertyFacadeExample.Domain;

namespace PropertyFacadeExample.ViewModel
{
    public interface IHasChanges
    {
        IReadOnlyValueObservable<bool> HasChanges { get; }
        void ResetValue();
        void UpdateOriginalValue();
    }
}

namespace PropertyFacadeExample.ViewModel
{
    public interface ITracksChanges
    {
        ChangeTracker ChangeTracker { get; }
    }
}

using System.Collections.Generic;
using System;

namespace PropertyFacadeExample
{
    public sealed class NullOrEmptyStringEqualityComparer : EqualityComparer<string>
    {
        public static new NullOrEmptyStringEqualityComparer Default { get; } = new NullOrEmptyStringEqualityComparer(StringComparer.InvariantCulture);

        public IEqualityComparer<string> InnerComparer { get; }

        public NullOrEmptyStringEqualityComparer(IEqualityComparer<string> innerComparer)
        {
            InnerComparer = innerComparer ?? throw new ArgumentNullException(nameof(innerComparer));
        }

        public override bool Equals(string x, string y)
        {
            if (string.IsNullOrEmpty(x) && string.IsNullOrEmpty(y))
            {
                return true;
            }
            else
            {
                return InnerComparer.Equals(x, y);
            }
        }

        public override int GetHashCode(string obj) => InnerComparer.GetHashCode(obj);
    }
}


using PropertyFacadeExample.Domain;
using System;

namespace PropertyFacadeExample.ViewModel
{
    public class PropertyFacade<T> : ReadOnlyPropertyFacade<T>, IHasChanges
    {
        public new T Value
        {
            get => base.Value;
            set
            {
                if (IsDisposed)
                {
                    throw new InvalidOperationException("The subscription for this observable has been disposed. Attach a new subscription by calling Observe.");
                }

                if (_valueCache is null)
                {
                    throw new InvalidOperationException("The observable has not been set yet. Attach a new subscription by calling Observe.");
                }

                _valueCache.SetValue(value);
            }
        }

        public PropertyFacade(UXViewModel viewModel, string propertyName)
            : base(viewModel, propertyName)
        { }

        public PropertyFacade(UXViewModel viewModel, IValueObservable<T> observable, string propertyName)
            : base(viewModel, observable, propertyName)
        { }

        public void ResetValue() => Value = OriginalValue;
    }
}


using PropertyFacadeExample.Domain;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reactive.Linq;
using System.Reactive.Subjects;

namespace PropertyFacadeExample.ViewModel
{
    [DebuggerDisplay("(PropertyFacade) {Value}")]
    public class ReadOnlyPropertyFacade<T> : IDisposable
    {
        private readonly UXViewModel _viewModel;
        private readonly string _propertyName;
        protected FacadeValueCache<T> _valueCache;
        private IDisposable _subscription;
        private T _oldValue;

        public bool IsDisposed { get; private set; }

        public T Value => _valueCache.HasObservable ? _valueCache.GetValue() : default;

        public T OriginalValue { get; protected set; }

        public IReadOnlyValueObservable<bool> HasChanges { get; }
        private readonly BehaviorSubject<bool> _hasChangesSubject = new BehaviorSubject<bool>(false);

        public bool SuppressDebugOutput { get; set; }

        public ReadOnlyPropertyFacade(UXViewModel viewModel, string propertyName)
        {
            _viewModel = viewModel ?? throw new ArgumentNullException(nameof(viewModel));
            _propertyName = propertyName;
            _valueCache = new FacadeValueCache<T>();

            HasChanges = _hasChangesSubject.ToCached();
        }

        public ReadOnlyPropertyFacade(UXViewModel viewModel, IReadOnlyValueObservable<T> observable, string propertyName)
            : this(viewModel, propertyName)
        {
            Observe(observable);
        }

        /// <summary>
        /// Attach the facade to an observable. If an observable is already attached, the subscription is disposed and the new one is attached in its place.
        /// </summary>
        /// <param name="newObservable"></param>
        /// <param name="equalityComparer"></param>
        public void Observe(IObservable<T> newObservable, IEqualityComparer<T> equalityComparer = null)
        {
            if (newObservable is null)
            {
                throw new ArgumentNullException(nameof(newObservable));
            }

            Dispose();

            _valueCache.Attach(newObservable);

            OriginalValue = _valueCache.GetValue();

            DebugMessage("PropertyFacade: New observable mounted on viewmodel='{0}', property='{1}', OriginalValue='{2}'", _viewModel, _propertyName, OriginalValue);

            equalityComparer = equalityComparer ?? GetEqualityComparer<T>();

            IsDisposed = false;

            _subscription = _valueCache.Subscribe(newValue =>
            {
                DebugMessage("PropertyFacade: Received value on viewmodel='{0}', property='{1}', value='{2}'", _viewModel, _propertyName, newValue);

                if (!equalityComparer.Equals(_oldValue, newValue))
                {
                    // Only pump HasChanges if the new HasChanges value is different.

                    bool changed = !equalityComparer.Equals(OriginalValue, newValue);

                    if (_hasChangesSubject.Value != changed)
                    {
                        _hasChangesSubject.OnNext(changed);
                    }

                    RaisePropertyChanged(newValue);
                }
            });
        }

        private IEqualityComparer<TValue> GetEqualityComparer<TValue>()
        {
            if (typeof(TValue) == typeof(string))
            {
                return (IEqualityComparer<TValue>)(IEqualityComparer<string>)NullOrEmptyStringEqualityComparer.Default;
            }
            else
            {
                return EqualityComparer<TValue>.Default;
            }
        }

        private void RaisePropertyChanged(T newValue)
        {
            DebugMessage("PropertyFacade: RaisePropertyChanging: '{0}', property='{1}', old='{2}', new='{3}'", _viewModel, _propertyName, _oldValue, newValue);
            _viewModel.RaisePropertyChanging(_propertyName);

            var oldTemp = _oldValue;
            _oldValue = newValue;

            DebugMessage("PropertyFacade: RaisePropertyChanged: '{0}', property='{1}', old='{2}', new='{3}'", _viewModel, _propertyName, oldTemp, newValue);
            _viewModel.RaisePropertyChanged(_propertyName);
        }

        public void UpdateOriginalValue()
        {
            OriginalValue = Value;

            if (HasChanges.Value)
            {
                _hasChangesSubject.OnNext(false);
            }
        }

        /// <summary>
        /// Disconnects any existing subscription. If none exists, no action is taken.
        /// </summary>
        public void Dispose()
        {
            IsDisposed = true;
            _subscription?.Dispose();
            _valueCache.Dispose();
        }

        [DebuggerStepThrough]
        protected void DebugMessage(string message, params object[] args)
        {
            if (!SuppressDebugOutput && Debugger.IsAttached)
            {
                Debug.WriteLine(message, args);
            }
        }
    }
}

using System.ComponentModel;

namespace PropertyFacadeExample.ViewModel
{
    /// <summary>
    /// A base view model implementation. If we were using ReactiveUI, this would also extend from ReactiveObject.
    /// </summary>
    public abstract class UXViewModel : INotifyPropertyChanged, INotifyPropertyChanging
    {
        public event PropertyChangedEventHandler PropertyChanged;
        public event PropertyChangingEventHandler PropertyChanging;

        public void RaisePropertyChanged(PropertyChangedEventArgs args) => PropertyChanged?.Invoke(this, args);
        public void RaisePropertyChanged(string propertyName) => RaisePropertyChanged(new PropertyChangedEventArgs(propertyName));

        public void RaisePropertyChanging(PropertyChangingEventArgs args) => PropertyChanging?.Invoke(this, args);
        public void RaisePropertyChanging(string propertyName) => RaisePropertyChanging(new PropertyChangingEventArgs(propertyName));

        public DisposableTracker DisposableTracker { get; } = new DisposableTracker();
    }
}


using System;
using System.Collections.Generic;
using System.Linq.Expressions;

namespace PropertyFacadeExample.ViewModel
{
    public static class UXViewModelExtensions
    {
        public static PropertyFacade<T> PropFacade<T, TViewModel>(this TViewModel vm, Expression<Func<TViewModel, T>> property)
            where TViewModel : UXViewModel
        {
            if (vm is null)
            {
                throw new ArgumentNullException(nameof(vm));
            }

            if (property is null)
            {
                throw new ArgumentNullException(nameof(property));
            }

            var memberExpr = (MemberExpression)property.Body;

            string propName = memberExpr.Member.Name;

            return new PropertyFacade<T>(vm, propName);
        }

        public static ReadOnlyPropertyFacade<T> ReadOnlyPropFacade<T, TViewModel>(this TViewModel vm, Expression<Func<TViewModel, T>> property)
            where TViewModel : UXViewModel
        {
            if (property is null)
            {
                throw new ArgumentNullException(nameof(property));
            }

            var memberExpr = (MemberExpression)property.Body;

            string propName = memberExpr.Member.Name;

            return new ReadOnlyPropertyFacade<T>(vm, propName);
        }

        public static void ToProperty<T>(this IObservable<T> observable, UXViewModel viewModel, ReadOnlyPropertyFacade<T> propertyFacade, IEqualityComparer<T> equalityComparer = null)
        {
            if (observable is null)
            {
                throw new ArgumentNullException(nameof(observable));
            }

            if (viewModel is null)
            {
                throw new ArgumentNullException(nameof(viewModel));
            }

            if (propertyFacade is null)
            {
                throw new ArgumentNullException(nameof(propertyFacade), "The property facade has not been initialized yet.");
            }

            propertyFacade.Observe(observable, equalityComparer);
            viewModel.DisposableTracker.Add(propertyFacade);
        }

        public static T DisposeWith<T>(this T disposable, UXViewModel viewModel) where T : class, IDisposable
        {
            if (disposable is null)
            {
                throw new ArgumentNullException(nameof(disposable));
            }

            if (viewModel is null)
            {
                throw new ArgumentNullException(nameof(viewModel));
            }

            viewModel.DisposableTracker.Add(disposable);

            return disposable;
        }

        public static T TrackChanges<T>(this T subject, ChangeTracker changeTracker)
            where T : class, IHasChanges
        {
            if (subject is null)
            {
                throw new ArgumentNullException(nameof(subject));
            }

            if (changeTracker is null)
            {
                throw new ArgumentNullException(nameof(changeTracker));
            }

            changeTracker.Add(subject);

            return subject;
        }

        public static T TrackChanges<T>(this T subject, ITracksChanges trackerOwner)
            where T : class, IHasChanges
        {
            if (subject is null)
            {
                throw new ArgumentNullException(nameof(subject));
            }

            if (trackerOwner is null)
            {
                throw new ArgumentNullException(nameof(trackerOwner));
            }

            return TrackChanges(subject, trackerOwner.ChangeTracker);
        }
    }
}

using System;
using System.Diagnostics;
using System.Reactive;

namespace PropertyFacadeExample.Domain
{
    public interface ICachedObservable<T> : IReadOnlyValueObservable<T>
    {
        bool HasValue { get; }
    }

    /// <summary>
    /// Represents an observable that caches the latest value of another observable.
    /// This observable has the same subscription semantics as ReplaySubject(1): if there is a value present, the value will replay when a subscription is made.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    [DebuggerDisplay("(CachedObservable) {Value}")]
    public sealed class CachedObservable<T> : ObservableBase<T>, ICachedObservable<T>
    {
        private readonly IDisposable _registration;
        private readonly IObservable<T> _source;

        public bool HasValue { get; private set; }

        public T Value { get; private set; }

        public CachedObservable(IObservable<T> source)
        {
            _source = source ?? throw new ArgumentNullException(nameof(source));

            _registration = _source.Subscribe(x =>
            {
                HasValue = true;
                Value = x;
            });
        }

        public void Dispose() => _registration.Dispose();

        protected override IDisposable SubscribeCore(IObserver<T> observer)
        {
            if (observer is null)
            {
                throw new ArgumentNullException(nameof(observer));
            }

            var sub = _source.SubscribeSafe(observer);

            if (HasValue)
            {
                observer.OnNext(Value);
            }

            return sub;
        }

        public override string ToString() => $"(CachedObservable) {Value}";
    }

    public static class CachedObservableExtensions
    {
        public static ICachedObservable<T> ToCached<T>(this IObservable<T> source) => new CachedObservable<T>(source);
    }
}

using System;

namespace PropertyFacadeExample.Domain
{
    internal static class RxDomain
    {
        public static IValueObservable<T> ObservableProperty<T>()
            => new ValueObservable<T>();

        public static IValueObservable<T> ObservableProperty<T>(T defaultValue, CoerceValueHandler<T> coerceValue = null)
            => new ValueObservable<T>(defaultValue, coerceValue);

        public static IValueObservable<T> ObservableProperty<T>(T defaultValue, CoerceValueHandler<T> coerceValue, out IDisposable coercerDelayToken)
        {
            var obs = new ValueObservable<T>(defaultValue, coerceValue, delayCoercer: true);
            coercerDelayToken = obs.GetCoercerDelayToken();
            return obs;
        }

        public static IValueObservable<T> ObservableProperty<T>(CoerceValueHandler<T> coerceValue)
            => new ValueObservable<T>(default, coerceValue);

        public static IReadOnlyValueObservable<T> ReadOnlyConstant<T>(T value)
            => new ReadOnlyConstantValueObservable<T>(value);
    }
}

using System;
using System.Diagnostics;
using System.Reactive.Disposables;
using System.Reactive.Subjects;

namespace PropertyFacadeExample.Domain
{

    public interface IReadOnlyValueObservable<T> : IObservable<T>, IDisposable
    {
        T Value { get; }
    }

    public interface IValueObservable<T> : IReadOnlyValueObservable<T>, ISubject<T>
    {
        new T Value { get; set; }
    }

    /// <summary>
    /// Same thing as Observable.Return() except as a <see cref="IReadOnlyValueObservable{T}"/>.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public sealed class ReadOnlyConstantValueObservable<T> : IReadOnlyValueObservable<T>
    {
        public T Value { get; }

        public ReadOnlyConstantValueObservable(T value) => Value = value;

        public void Dispose()
        { }

        public IDisposable Subscribe(IObserver<T> observer)
        {
            if (observer is null)
            {
                throw new ArgumentNullException(nameof(observer));
            }

            observer.OnNext(Value);

            return Disposable.Empty;
        }
    }

    public delegate T CoerceValueHandler<T>(T oldValue, T newValue);

    /// <summary>
    /// Represents a reactive subject that caches the latest value. It exhibits the same behavior as
    /// <see cref="BehaviorSubject{T}"/> except it has a settable <see cref="Value"/> property.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    [DebuggerDisplay("(ValueObservable) {Value}")]
    public sealed class ValueObservable<T> : IValueObservable<T>
    {
        private readonly BehaviorSubject<T> _subject;
        private readonly CoerceValueHandler<T> _coerceValue;

        public ValueObservable(T initialValue = default, CoerceValueHandler<T> coerceValue = default, bool delayCoercer = false)
        {
            _coerceValue = coerceValue ?? ((_, newValue) => newValue);
            _subject = new BehaviorSubject<T>(delayCoercer ? initialValue : _coerceValue.Invoke(default, initialValue));
        }

        public T Value
        {
            get => _subject.Value;
            set => OnNext(value);
        }

        public IDisposable Subscribe(IObserver<T> observer) => _subject.SubscribeSafe(observer);

        public void OnCompleted() => _subject.OnCompleted();

        public void OnError(Exception error) => _subject.OnError(error);

        public void OnNext(T newValue) => _subject.OnNext(_coerceValue.Invoke(Value, newValue));

        public void Dispose() => _subject.Dispose();

        public override string ToString() => $"(ValueObservable<{typeof(T).Name}>) {Value}";

        public void CoerceCurrent() => _coerceValue.Invoke(Value, Value);

        public IDisposable GetCoercerDelayToken() => Disposable.Create(() => CoerceCurrent());
    }

    /// <summary>
    /// Allows you to build custom observer logic for complex coercion scenarios.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public sealed class ValueObservableFacade<T> : IValueObservable<T>
    {
        private readonly IObservable<T> _observable;
        private readonly IObserver<T> _observer;
        private readonly Func<T> _getValue;
        private readonly Action<T> _setValue;

        public ValueObservableFacade(IObservable<T> observable, IObserver<T> observer, Func<T> getValue, Action<T> setValue = null)
        {
            _observable = observable ?? throw new ArgumentNullException(nameof(observable));
            _observer = observer ?? throw new ArgumentNullException(nameof(observer));
            _getValue = getValue ?? throw new ArgumentNullException(nameof(getValue));
            _setValue = setValue;

            _observable.Subscribe(next => Value = next);
        }

        /// <summary>
        /// Gets or sets the value. If the value is the same as the one stored, observers will not be notified. Use <see cref="OnNext(T)"/> to override this.
        /// </summary>
        public T Value
        {
            get => _getValue();
            set
            {
                if (!Equals(value, _getValue()))
                {
                    OnNext(value);
                }
            }
        }

        public void Dispose()
        {
            if (_observer is IDisposable d)
            {
                d.Dispose();
            }
        }

        public void OnCompleted() => _observer.OnCompleted();

        public void OnError(Exception error) => _observer.OnError(error);

        public void OnNext(T value)
        {
            _setValue?.Invoke(value);
            _observer.OnNext(value);
        }

        public IDisposable Subscribe(IObserver<T> observer) => _observable.SubscribeSafe(observer);
    }
}

using System.Linq;
using System.Reactive.Linq;
using static PropertyFacadeExample.Domain.RxDomain;

namespace PropertyFacadeExample.Domain.Models
{
    /// <summary>
    /// An example domain model that encapsulates working time in hours.
    /// </summary>
    public sealed class WorkingAttendance
    {
        public IValueObservable<decimal> AdminATime { get; }
        public IValueObservable<decimal> AdminBTime { get; }
        public IValueObservable<decimal> NonSalaryTime { get; }
        public IValueObservable<decimal> SalaryTime { get; }
        public IValueObservable<decimal> TravelTime { get; }
        public IValueObservable<decimal> LeaveTime { get; }

        public IReadOnlyValueObservable<decimal> TotalTime { get; }

        public WorkingAttendance(
            decimal administrativeATime,
            decimal administrativeBTime,
            decimal nonSalaryTime,
            decimal salaryTime,
            decimal travelTime,
            decimal leaveTime)
        {
            AdminATime = ObservableProperty(administrativeATime, ClipNegativeHoursToZero);
            AdminBTime = ObservableProperty(administrativeBTime, ClipNegativeHoursToZero);
            NonSalaryTime = ObservableProperty(nonSalaryTime);
            SalaryTime = ObservableProperty(salaryTime);
            TravelTime = ObservableProperty(travelTime);
            LeaveTime = ObservableProperty(leaveTime, ClipNegativeHoursToZero);

            TotalTime = Observable.CombineLatest(
                AdminATime,
                AdminBTime,
                NonSalaryTime,
                SalaryTime,
                TravelTime,
                LeaveTime)
                .Select(hours => hours.Sum())
                .ToCached();
        }

        private static decimal ClipNegativeHoursToZero(decimal _, decimal newTime) => newTime < 0 ? 0 : newTime;
    }
}