Is locking better that ToList()?

Author: gave92

src/Files.Uwp/Files.Uwp.csproj

@@ -186,6 +186,7 @@
     <Compile Include="Helpers\ColorHelpers.cs" />
     <Compile Include="Helpers\CommonPaths.cs" />
     <Compile Include="Helpers\FileExtensionHelpers.cs" />
+    <Compile Include="Helpers\ItemListDisplayHelpers\BlockingListEnumerator.cs" />
     <Compile Include="Helpers\LocalizedEnumHelper.cs" />
     <Compile Include="Helpers\ResourceHelpers.cs" />
     <Compile Include="Helpers\FtpHelpers.cs" />

src/Files.Uwp/Helpers/ItemListDisplayHelpers/BlockingListEnumerator.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Files.Helpers
+{
+    public class BlockingListEnumerator<T> : IEnumerator<T>
+    {
+        private readonly IList<T> m_Inner;
+        private readonly object m_Lock;
+        private int m_Pos;
+
+        public BlockingListEnumerator(IList<T> inner, object @lock)
+        {
+            m_Inner = inner;
+            m_Lock = @lock;
+            m_Pos = -1;
+        }
+
+        public T Current
+        {
+            get
+            {
+                lock (m_Lock)
+                {
+                    if (m_Pos < m_Inner.Count)
+                    {
+                        return m_Inner[m_Pos];
+                    }
+                    throw new IndexOutOfRangeException();
+                }
+            }
+        }
+
+        object IEnumerator.Current => Current;
+
+        public void Dispose()
+        {
+        }
+
+        public bool MoveNext()
+        {
+            lock (m_Lock)
+            {
+                m_Pos++;
+                return m_Pos < m_Inner.Count;
+            }
+        }
+
+        public void Reset()
+        {
+            lock (m_Lock)
+            {
+                m_Pos = -1;
+            }
+        }
+    }
+}

src/Files.Uwp/Helpers/ItemListDisplayHelpers/BulkConcurrentObservableCollection.cs

@@ -295,10 +295,7 @@ public bool Remove(T item)
 
         public IEnumerator<T> GetEnumerator()
         {
-            lock (syncRoot)
-            {
-                return collection.ToList().GetEnumerator();
-            }
+            return new BlockingListEnumerator<T>(collection, syncRoot);
         }
 
         IEnumerator IEnumerable.GetEnumerator()