Make non-generic IList implementation explicit and pull a few public Reactive List methods up to its interface. Fixes #485

Author: Oren Novotny

ReactiveUI/Interfaces.cs

@@ -285,6 +285,8 @@ public interface IReactiveNotifyCollectionChanged : INotifyCollectionChanged
         /// Doing It Wrong.
         /// </summary>
         IObservable<Unit> ShouldReset { get; }
+
+        IDisposable SuppressChangeNotifications();
     }
 
     /// <summary>
@@ -338,6 +340,7 @@ public interface IReactiveNotifyCollectionChanged<out T> : IReactiveNotifyCollec
     /// </summary>
     public interface IReactiveCollection<out T> : IReactiveNotifyCollectionChanged<T>, IReactiveNotifyCollectionItemChanged<T>, IEnumerable<T>, INotifyPropertyChanging, INotifyPropertyChanged, IEnableLogger
     {
+        void Reset();
     }
 
     /// <summary>
@@ -386,6 +389,18 @@ public interface IReactiveDerivedList<T> : IReadOnlyReactiveList<T>, IDisposable
     /// </summary>
     public interface IReactiveList<T> : IReactiveCollection<T>, IList<T>
     {
+        void AddRange(IEnumerable<T> collection);
+
+        void InsertRange(int index, IEnumerable<T> collection);
+        void RemoveAll(IEnumerable<T> items);
+
+        void RemoveRange(int index, int count);
+
+        void Sort(IComparer<T> comparer = null);
+
+        void Sort(Comparison<T> comparison);
+
+        void Sort(int index, int count, IComparer<T> comparer);
     }
 
     // NB: This is just a name we can bolt extension methods to

ReactiveUI/ReactiveList.cs

@@ -711,30 +711,30 @@ public virtual T this[int index] {
             set { SetItem(index, value); }
         }
 
-        public int Add(object value)
+        int IList.Add(object value)
         {
             Add((T)value);
             return Count - 1;
         }
 
-        public bool Contains(object value)
+        bool IList.Contains(object value)
         {
             return IsCompatibleObject(value) && Contains((T)value);
         }
 
-        public int IndexOf(object value)
+        int IList.IndexOf(object value)
         {
             return IsCompatibleObject(value) ? IndexOf((T)value) : -1;
         }
 
-        public void Insert(int index, object value)
+        void IList.Insert(int index, object value)
         {
             Insert(index, (T)value);
         }
 
-        public bool IsFixedSize { get { return false; } }
+        bool IList.IsFixedSize { get { return false; } }
 
-        public void Remove(object value)
+        void IList.Remove(object value)
         {
             if (IsCompatibleObject(value)) Remove((T)value);
         }
@@ -745,14 +745,14 @@ object IList.this[int index]
             set { this[index] = (T)value; }
         }
 
-        public void CopyTo(Array array, int index)
+        void ICollection.CopyTo(Array array, int index)
         {
             ((IList)_inner).CopyTo(array, index);
         }
 
-        public bool IsSynchronized { get { return false; } }
+        bool ICollection.IsSynchronized { get { return false; } }
 
-        public object SyncRoot { get { return this; } }
+        object ICollection.SyncRoot { get { return this; } }
 
         private static bool IsCompatibleObject(object value)
         {
@@ -768,7 +768,7 @@ public interface IMoveInfo<out T>
         int To { get; }
     }
 
-    public class MoveInfo<T> : IMoveInfo<T>
+    internal class MoveInfo<T> : IMoveInfo<T>
     {
         public IEnumerable<T> MovedItems { get; protected set; }
         public int From { get; protected set; }