Added Range Manipulation APIs to Collection<T> and ObservableCollecti…

…on<T> (dotnet#35772)

* Added Collection<T> AddRange and InsertRange and added new XUnit tests to cover new APIs

Added missing APIs from Collection<T>; Added new unit tests for RemoveRange, ReplaceRange, InsertItemsRange and RemoveItemsRange

Updated AddRange in Collection<T> to add items to the end of the collection

Added CollectionChanged tests for ObservableCollection<T> for InsertRange, AddRange, RemoveRange and ReplaceRange

Removing API changes as these will be mirrored from CoreCLR

Updated array assertions to use Span<T> to simplify logic

Sorted order of new API methods

Simplified CollectionTests Assertion to use Span<T> instead of calling out each item in the array

Added missing API ReplaceItemsRange and updated unit tests for check for overflow errors on RemoveItems

Added overrides for ObservableCollection<T> ItemsRange API to only fire CollectionChanged once per API call. Before this was firing for each item in the collection which is not the desired result. Updated unit tests to verify this logic

Updated RemoveItemsRange to prevent int.MaxValue overflow errors

Added int.MaxValue overflow tests for Collection<T> and ObservableCollection<T> when invoking RemoveItemsRange API

Added additional RemoveRange unit tests to cover when Count is Less than 0 or when Count is 0

Updated RemoveRange overflow tests to check for ArgumentException for new business rules

Updated ObservableCollection overflow test to assert ArgumentException

Added try-finally block to ObservableCollection<T> to certify that _skipCollectionChanged is always set to false after a collection manipulation in case an exception is thrown in a subclass. Added new test class to test the new rules on the example of a NonNullObservableCollection<T>

CollectionChanged events do not fire on RemoveRange if the count == 0

Updated ObservableCollection<T> to only throw the 3 required events when ReplaceItemsRange is invoked. Updated OnChangedEvent methods to check for IList and cast as necessary. Added additional exception handling to reset _skipRaisingEvents bool. Added unit tests to verify event and event parameters are being passed correctly.

Added Collection<T> AddRange and InsertRange and added new XUnit tests to cover new APIs

Simplified CollectionTests Assertion to use Span<T> instead of calling out each item in the array

Added additional RemoveRange unit tests to cover when Count is Less than 0 or when Count is 0

Updated ObservableCollection<T> to only throw the 3 required events when ReplaceItemsRange is invoked. Updated OnChangedEvent methods to check for IList and cast as necessary. Added additional exception handling to reset _skipRaisingEvents bool. Added unit tests to verify event and event parameters are being passed correctly.

Updated ReplaceRange event to pass in the OldItems and NewItems to match the event docs

Simplified CollectionChanged 'NewItems for InsertItemsRange

Updated removedItems to use an array instead of a List<T>

Added new OnCollectionChanged overloads to reduce need for additional if checks.

Removed stale code

Optimized ReplaceItemsRange by simplifying the itemsToReplace which is no an array instead of a List<T>

Removed (IList) cast in ReplaceItemsRange when raising CollectionChanged

Removed temp array in RemoveRange which decreases memory allocation needed

* Removed redudent AsSpan parameter in test code

* Removed stale code in test code

* Removed redundent Assert.NotNull calls in several tests

* Added additional check in InsertRange to verify the input collection.Count is greater than 0 before raising the events

* Removed stale code from the `NonNullObservableCollection<T>` test harness

* Removed unnecessary whitespace

* Renamed new API tests to include the .netcoreapp extension; Updated .Tests.csproj file to only run them when the project is built under .NET core as net standard is the default

* Renamed CollectionTests -> CollectionTests.netcoreapp.cs and only run the test if it is a netcoreapp as the new APIs aren't in netstandard yet

* Added UAP and UAPAOT build configurations for System.ObjectModel tests

* Updated ObservableCollection/Collection tests that use new APIs to be in a partial class with the .netcoreapp.cs extension and existings tests to be in the .cs file.

* Added CollectionTestBase as parent class for CollectionTests for the use case where the other tests are ignored in netstandard builds

* Adding using statements back in which were failing the build

* Moving private classes from the netcoreapp tests to the regular CollectionTests as they were not available in the netstandard CI test run

* Added missing using statement for colleciton tests

* Added if-block that certifies we have replaced items before raising the Replace Event on ReplaceItemsRange

* Removed whitespace in System.Runtime.Tests.csproj

* Added negative test case for ReplaceRange when no items are replaced

* Fixed issue with failing test

src/System.ObjectModel/src/System/Collections/ObjectModel/ObservableCollection.cs

@@ -27,6 +27,9 @@ public class ObservableCollection<T> : Collection<T>, INotifyCollectionChanged,
         [NonSerialized]
         private int _blockReentrancyCount;
 
+        [NonSerialized]
+        private bool _skipRaisingEvents;
+
         /// <summary>
         /// Initializes a new instance of ObservableCollection that is empty and has default initial capacity.
         /// </summary>
@@ -121,9 +124,95 @@ protected override void RemoveItem(int index)
 
             base.RemoveItem(index);
 
-            OnCountPropertyChanged();
-            OnIndexerPropertyChanged();
-            OnCollectionChanged(NotifyCollectionChangedAction.Remove, removedItem, index);
+            if (!_skipRaisingEvents)
+            {
+                OnCountPropertyChanged();
+                OnIndexerPropertyChanged();
+                OnCollectionChanged(NotifyCollectionChangedAction.Remove, removedItem, index);
+            }
+        }
+
+        /// <summary>
+        /// Called by base class Collection&lt;T&gt; when a count of items is removed from the list;
+        /// raises a CollectionChanged event to any listeners.
+        /// </summary>
+        protected override void RemoveItemsRange(int index, int count)
+        {
+            CheckReentrancy();
+
+            T[] removedItems = null;
+
+            bool ignore = _skipRaisingEvents;
+            if (!ignore)
+            {
+                _skipRaisingEvents = true;
+
+                if (count > 0)
+                {
+                    removedItems = new T[count];
+                    for (int i = 0; i < count; i++)
+                    {
+                        removedItems[i] = this[index + i];
+                    }
+                }
+            }
+
+            try
+            {
+                base.RemoveItemsRange(index, count);
+            }
+            finally
+            {
+                if (!ignore)
+                {
+                    _skipRaisingEvents = false;
+                }
+            }
+
+            if (count > 0 && !_skipRaisingEvents)
+            {
+                OnCountPropertyChanged();
+                OnIndexerPropertyChanged();
+                OnCollectionChanged(NotifyCollectionChangedAction.Remove, removedItems, index);
+            }
+        }
+
+        /// <summary>
+        /// Called by base class Collection&lt;T&gt; when a collection of items is added to list;
+        /// raises a CollectionChanged event to any listeners.
+        /// </summary>
+        protected override void ReplaceItemsRange(int index, int count, IEnumerable<T> collection)
+        {
+            CheckReentrancy();
+
+            _skipRaisingEvents = true;
+
+            T[] itemsToReplace = new T[count - index];
+            for (int i = index; i < count; i++)
+            {
+                itemsToReplace[i] = this[i];
+            }
+
+            try
+            {
+                base.ReplaceItemsRange(index, count, collection);
+            }
+            finally
+            {
+                _skipRaisingEvents = false;
+            }
+
+            if (!_skipRaisingEvents)
+            {
+                IList newItems = collection is IList list ? list : new List<T>(collection);
+
+                if (newItems.Count > 0)
+                {
+                    OnCountPropertyChanged();
+                    OnIndexerPropertyChanged();
+                    OnCollectionChanged(NotifyCollectionChangedAction.Replace, itemsToReplace, newItems, index);
+                }
+            }
         }
 
         /// <summary>
@@ -135,9 +224,51 @@ protected override void InsertItem(int index, T item)
             CheckReentrancy();
             base.InsertItem(index, item);
 
-            OnCountPropertyChanged();
-            OnIndexerPropertyChanged();
-            OnCollectionChanged(NotifyCollectionChangedAction.Add, item, index);
+            if (!_skipRaisingEvents)
+            {
+                OnCountPropertyChanged();
+                OnIndexerPropertyChanged();
+                OnCollectionChanged(NotifyCollectionChangedAction.Add, item, index);
+            }
+        }
+
+        /// <summary>
+        /// Called by base class Collection&lt;T&gt; when a collection of items is added to list;
+        /// raises a CollectionChanged event to any listeners.
+        /// </summary>
+        protected override void InsertItemsRange(int index, IEnumerable<T> collection)
+        {
+            CheckReentrancy();
+
+            bool ignore = _skipRaisingEvents;
+            if (!ignore)
+            {
+                _skipRaisingEvents = true;
+            }
+
+            try
+            {
+                base.InsertItemsRange(index, collection);
+            }
+            finally
+            {
+                if (!ignore)
+                {
+                    _skipRaisingEvents = false;
+                }
+            }
+
+            if (!_skipRaisingEvents)
+            {
+                IList newItems = collection is IList list ? list : new List<T>(collection);
+
+                if (newItems.Count > 0)
+                {
+                    OnCountPropertyChanged();
+                    OnIndexerPropertyChanged();
+                    OnCollectionChanged(NotifyCollectionChangedAction.Add, newItems, index);
+                }
+            }
         }
 
         /// <summary>
@@ -265,6 +396,14 @@ private void OnCollectionChanged(NotifyCollectionChangedAction action, object it
             OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, item, index));
         }
 
+        /// <summary>
+        /// Helper to raise CollectionChanged event to any listeners
+        /// </summary>
+        private void OnCollectionChanged(NotifyCollectionChangedAction action, IList items, int index)
+        {
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, items, index));
+        }
+
         /// <summary>
         /// Helper to raise CollectionChanged event to any listeners
         /// </summary>
@@ -281,6 +420,14 @@ private void OnCollectionChanged(NotifyCollectionChangedAction action, object ol
             OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, newItem, oldItem, index));
         }
 
+        /// <summary>
+        /// Helper to raise CollectionChanged event to any listeners
+        /// </summary>
+        private void OnCollectionChanged(NotifyCollectionChangedAction action, IList oldItems, IList newItems, int index)
+        {
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, newItems, oldItems, index));
+        }
+
         /// <summary>
         /// Helper to raise CollectionChanged event with action == Reset to any listeners
         /// </summary>

src/System.ObjectModel/tests/Configurations.props

@@ -3,6 +3,8 @@
     <BuildConfigurations>
       netstandard;
       netcoreapp;
+      uap;
+      uapaot;
     </BuildConfigurations>
   </PropertyGroup>
 </Project>