Add and update Intellisense comments in ReactiveDomain.UI and ReactiveDomain.UI.Testing classes (#103)

* Add Intellisense comments to classes in ReactiveDomain.UI and ReactiveDomain.UI.Testing.
* Minor performance improvement to Asserts: avoid creating an anonymous delegate at runtime, which is slower than specifying an expression lambda at compile time.

Author: joshkempner

src/ReactiveDomain.UI.Testing/Asserts.cs

@@ -14,7 +14,7 @@ public class Asserts
         /// <param name="cmd">The command whose CanExecute is to be compared</param>
         public static void CanExecute<TIn, TOut>(ReactiveCommand<TIn, TOut> cmd)
         {
-            using (cmd.CanExecute.Replay(1).RefCount().ObserveOn(RxApp.MainThreadScheduler).Subscribe(Xunit.Assert.True)) { }
+            using (cmd.CanExecute.Replay(1).RefCount().ObserveOn(RxApp.MainThreadScheduler).Subscribe(x => Xunit.Assert.True(x))) { }
         }
 
         /// <summary>
@@ -25,7 +25,7 @@ public static void CanExecute<TIn, TOut>(ReactiveCommand<TIn, TOut> cmd)
         /// <param name="cmd">The command whose CanExecute is to be compared</param>
         public static void CannotExecute<TIn, TOut>(ReactiveCommand<TIn, TOut> cmd)
         {
-            using (cmd.CanExecute.Replay(1).RefCount().ObserveOn(RxApp.MainThreadScheduler).Subscribe(Xunit.Assert.False)) { }
+            using (cmd.CanExecute.Replay(1).RefCount().ObserveOn(RxApp.MainThreadScheduler).Subscribe(x => Xunit.Assert.False(x))) { }
         }
     }
 }

src/ReactiveDomain.UI/Bus/ReactiveTransientSubscriber.cs

@@ -8,35 +8,69 @@
 
 namespace ReactiveDomain.UI
 {
+    /// <summary>
+    /// A <see cref="ReactiveObject"/> that implements Subscribe on the injected bus and
+    /// that auto-unsubscribes when disposed.
+    /// </summary>
     public abstract class ReactiveTransientSubscriber : ReactiveObject, IDisposable
     {
         private readonly List<IDisposable> _subscriptions = new List<IDisposable>();
         private readonly ISubscriber _eventSubscriber;
         private readonly ICommandSubscriber _commandSubscriber;
 
+        /// <summary>
+        /// Creates a <see cref="ReactiveTransientSubscriber"/> with the injected dispatcher.
+        /// </summary>
+        /// <param name="bus">The dispatcher on which to subscribe to commands.</param>
+        /// <exception cref="ArgumentNullException"><c>bus</c> is <c>null</c></exception>
         protected ReactiveTransientSubscriber(IDispatcher bus) : this((IBus)bus)
         {
             _commandSubscriber = bus ?? throw new ArgumentNullException(nameof(bus));
         }
 
-        protected ReactiveTransientSubscriber(IBus bus) : this((ISubscriber) bus) {}
+        /// <summary>
+        /// Creates a <see cref="ReactiveTransientSubscriber"/> with the injected bus.
+        /// </summary>
+        /// <param name="bus">The bus on which to subscribe to messages.</param>
+        /// <exception cref="ArgumentNullException"><c>bus</c> is <c>null</c></exception>
+        protected ReactiveTransientSubscriber(IBus bus) : this((ISubscriber) bus) { }
 
+        /// <summary>
+        /// Creates a <see cref="ReactiveTransientSubscriber"/> with the injected bus.
+        /// </summary>
+        /// <param name="subscriber">The <see cref="ISubscriber"/> on which to subscribe to messages.</param>
+        /// <exception cref="ArgumentNullException"><c>bus</c> is <c>null</c></exception>
         protected ReactiveTransientSubscriber(ISubscriber subscriber)
         {
             _eventSubscriber = subscriber ?? throw new ArgumentNullException(nameof(subscriber));
         }
 
+        /// <summary>
+        /// Subscribes to messages of type T on the bus. This is typically used when subscribing to events.
+        /// </summary>
+        /// <typeparam name="T">The type of messages to subscribe to.</typeparam>
+        /// <param name="handler">A handler for messages of type T.</param>
         protected void Subscribe<T>(IHandle<T> handler) where T : class, IMessage
         {
             _subscriptions.Add(_eventSubscriber.Subscribe<T>(handler));
         }
 
+        /// <summary>
+        /// Subscribes to commands of type T on the bus.
+        /// </summary>
+        /// <typeparam name="T">The type of commands to subscribe to.</typeparam>
+        /// <param name="handler">A handler for commands of type T.</param>
+        /// <exception cref="ArgumentOutOfRangeException">The class has not been given an
+        /// <see cref="IDispatcher"/> on which to subscribe to commands.</exception>
         protected void Subscribe<T>(IHandleCommand<T> handler) where T : Command
         {
             if (_commandSubscriber == null) throw new ArgumentOutOfRangeException(nameof(handler), @"TransientSubscriber not created with CommandBus to register on.");
             _subscriptions.Add(_commandSubscriber.Subscribe<T>(handler));
         }
 
+        /// <summary>
+        /// Unsubscribes from all subscribed message types on the bus.
+        /// </summary>
         public void Dispose()
         {
             Dispose(true);
@@ -47,10 +81,10 @@ protected virtual void Dispose(bool disposing)
         {
             if (_disposed)
                 return;
-            if (disposing){
+            if (disposing) {
                 _subscriptions?.ForEach(s => s.Dispose());
             }
-           _disposed = true;
+            _disposed = true;
         }
     }
 }

src/ReactiveDomain.UI/ReadModel/ReadModelProperty.cs

@@ -5,11 +5,24 @@
 
 namespace ReactiveDomain.UI
 {
-
+    /// <summary>
+    /// A wrapper for an observable provider, intended for use in transient read models.
+    /// This provider is a hot observable. Includes simple semantics for appending a new
+    /// item to the provider. Late subscribers are automatically provided with the most
+    /// recent value upon subscription.
+    /// </summary>
+    /// <typeparam name="T">The type of data for the provider.</typeparam>
     public class ReadModelProperty<T> : IObservable<T>
     {
         private readonly List<IObserver<T>> _subscribed = new List<IObserver<T>>();
         private readonly IObservable<T> _observable;
+
+        /// <summary>
+        /// Creates a new <see cref="ReadModelProperty{T}"/>.
+        /// </summary>
+        /// <param name="startValue">The provider's initial value.</param>
+        /// <param name="publishWrapper">An optional wrapper to use when providing
+        /// new values to subscribers.</param>
         public ReadModelProperty(T startValue, Action<Action> publishWrapper = null)
         {
             _lastValue = startValue;
@@ -19,12 +32,19 @@ public ReadModelProperty(T startValue, Action<Action> publishWrapper = null)
                 _subscribed.Add(o);
                 return () => _subscribed.Remove(o);
             });
-
         }
 
         private T _lastValue;
         private readonly Action<Action> _publishWrapper;
 
+        /// <summary>
+        /// Append an item to the provider's stream and notifies all subscribers.
+        /// The stream is unchanged and no notifications are made if the provided
+        /// value is the same as the previous value.
+        /// </summary>
+        /// <param name="val">The value to be appended to the stream.</param>
+        /// <param name="force">Forces notifications. If true, notifies subscribers of
+        /// the new value even if that value is the same as the previous value.</param>
         public void Update(T val, bool force = false)
         {
             var noChange = (val != null && val.Equals(_lastValue)) || (val == null && _lastValue == null);
@@ -41,6 +61,14 @@ public void Update(T val, bool force = false)
                     subscriber.OnNext(val);
             }
         }
+
+        /// <summary>
+        /// Subscribes a new observer to this observable and asynchronously notifies
+        /// that observer of the most recent value.
+        /// </summary>
+        /// <param name="observer">The observer to subscribe.</param>
+        /// <returns>A reference to an interface that allows observers to stop receiving
+        /// notifications before the provider has finished sending them.</returns>
         public IDisposable Subscribe(IObserver<T> observer)
         {
             var unsubscribe = _observable.Subscribe(observer);