Use array instead of List<T>

Author: AaronRobinsonMSFT

src/libraries/Common/src/System/Runtime/InteropServices/ComEventsMethod.cs

@@ -100,7 +100,7 @@ private void PreProcessSignature()
         /// Since multicast delegate's built-in chaining supports only chaining instances of the same type,
         /// we need to complement this design by using an explicit linked list data structure.
         /// </summary>
-        private List<DelegateWrapper> _delegateWrappers = new List<DelegateWrapper>();
+        private DelegateWrapper[] _delegateWrappers = Array.Empty<DelegateWrapper>();
 
         private readonly int _dispid;
         private ComEventsMethod? _next;
@@ -157,15 +157,15 @@ public bool Empty
         {
             get
             {
-                List<DelegateWrapper> wrappers = _delegateWrappers;
-                return wrappers.Count == 0;
+                DelegateWrapper[] wrappers = _delegateWrappers;
+                return wrappers.Length == 0;
             }
         }
 
         public void AddDelegate(Delegate d, bool wrapArgs = false)
         {
-            List<DelegateWrapper> wrappers;
-            List<DelegateWrapper> newWrappers;
+            DelegateWrapper[] wrappers;
+            DelegateWrapper[] newWrappers;
             do
             {
                 wrappers = _delegateWrappers;
@@ -180,26 +180,25 @@ public void AddDelegate(Delegate d, bool wrapArgs = false)
                     }
                 }
 
-                newWrappers = wrappers.Count == 0
-                    ? new List<DelegateWrapper>()
-                    : wrappers.GetRange(0, wrappers.Count);
+                newWrappers = new DelegateWrapper[wrappers.Length + 1];
+                wrappers.CopyTo(newWrappers, 0);
 
-                newWrappers.Add(new DelegateWrapper(d, wrapArgs));
+                newWrappers[newWrappers.Length - 1] = new DelegateWrapper(d, wrapArgs);
             } while (!PublishNewWrappers(newWrappers, wrappers));
         }
 
         public void RemoveDelegate(Delegate d, bool wrapArgs = false)
         {
-            List<DelegateWrapper> wrappers;
-            List<DelegateWrapper> newWrappers;
+            DelegateWrapper[] wrappers;
+            DelegateWrapper[] newWrappers;
             do
             {
                 wrappers = _delegateWrappers;
 
                 // Find delegate wrapper index
                 int removeIdx = -1;
                 DelegateWrapper? wrapper = null;
-                for (int i = 0; i < wrappers.Count; i++)
+                for (int i = 0; i < wrappers.Length; i++)
                 {
                     DelegateWrapper wrapperMaybe = wrappers[i];
                     if (wrapperMaybe.Delegate.GetType() == d.GetType() && wrapperMaybe.WrapArgs == wrapArgs)
@@ -224,22 +223,22 @@ public void RemoveDelegate(Delegate d, bool wrapArgs = false)
                     return; // No need to update collection
                 }
 
-                newWrappers = wrappers.GetRange(0, wrappers.Count);
-                newWrappers.RemoveAt(removeIdx);
+                newWrappers = new DelegateWrapper[wrappers.Length - 1];
+                wrappers.AsSpan(0, removeIdx).CopyTo(newWrappers);
+                wrappers.AsSpan(removeIdx + 1).CopyTo(newWrappers.AsSpan(removeIdx));
             } while (!PublishNewWrappers(newWrappers, wrappers));
         }
 
         public void RemoveDelegates(Func<Delegate, bool> condition)
         {
-            List<DelegateWrapper> wrappers;
-            List<DelegateWrapper> newWrappers;
+            DelegateWrapper[] wrappers;
+            DelegateWrapper[] newWrappers;
             do
             {
                 wrappers = _delegateWrappers;
 
-                // Find delegate wrapper indexes. Iterate in reverse such that the list to remove is sorted by high to low index.
                 List<int> toRemove = new List<int>();
-                for (int i = wrappers.Count - 1; i >= 0; i--)
+                for (int i = 0; i < wrappers.Length; i++)
                 {
                     DelegateWrapper wrapper = wrappers[i];
                     Delegate[] invocationList = wrapper.Delegate.GetInvocationList();
@@ -266,20 +265,43 @@ public void RemoveDelegates(Func<Delegate, bool> condition)
                     return;
                 }
 
-                newWrappers = wrappers.GetRange(0, wrappers.Count);
-                foreach (int idx in toRemove)
+                newWrappers = RemoveAll(wrappers, CollectionsMarshal.AsSpan(toRemove));
+            } while (!PublishNewWrappers(newWrappers, wrappers));
+
+            // The list of indices is assumed to be sorted in ascending order
+            static DelegateWrapper[] RemoveAll(DelegateWrapper[] oldCol, ReadOnlySpan<int> toRemove)
+            {
+                // Allocate new collection
+                var newCol = new DelegateWrapper[oldCol.Length - toRemove.Length];
+                if (newCol.Length == 0)
                 {
-                    newWrappers.RemoveAt(idx);
+                    return newCol;
                 }
-            } while (!PublishNewWrappers(newWrappers, wrappers));
+
+                // Iterate over collection, skipping elements that should be removed.
+                int ri = 0;
+                for (int oi = 0, ni = 0; oi < oldCol.Length; oi++)
+                {
+                    if (ri < toRemove.Length && oi == toRemove[ri])
+                    {
+                        ri++;
+                        continue;
+                    }
+
+                    newCol[ni] = oldCol[oi];
+                    ni++;
+                }
+
+                return newCol;
+            }
         }
 
         public object? Invoke(object[] args)
         {
             Debug.Assert(!Empty);
             object? result = null;
 
-            List<DelegateWrapper> wrappers = _delegateWrappers;
+            DelegateWrapper[] wrappers = _delegateWrappers;
             foreach (DelegateWrapper wrapper in wrappers)
             {
                 result = wrapper.Invoke(args);
@@ -289,7 +311,7 @@ public void RemoveDelegates(Func<Delegate, bool> condition)
         }
 
         // Attempt to update the member wrapper field
-        private bool PublishNewWrappers(List<DelegateWrapper> newWrappers, List<DelegateWrapper> currentMaybe)
+        private bool PublishNewWrappers(DelegateWrapper[] newWrappers, DelegateWrapper[] currentMaybe)
         {
             return Interlocked.CompareExchange(ref _delegateWrappers, newWrappers, currentMaybe) == currentMaybe;
         }