From 5fd827cce876537c04ddbce63f255438203349d8 Mon Sep 17 00:00:00 2001
From: prozolic <42107886+prozolic@users.noreply.github.com>
Date: Wed, 22 Oct 2025 13:54:09 +0900
Subject: [PATCH] Fix List<T> to ListView<T> casting bug on .NET Framework

---
 .../Shims/Collections.cs                      | 121 ++++++++++++------
 .../Shims/CollectionsMarshalEx.cs             |  50 +++++++-
 2 files changed, 122 insertions(+), 49 deletions(-)

diff --git a/src/ObservableCollections/Shims/Collections.cs b/src/ObservableCollections/Shims/Collections.cs
index c4ae823..7add725 100644
--- a/src/ObservableCollections/Shims/Collections.cs
+++ b/src/ObservableCollections/Shims/Collections.cs
@@ -45,16 +45,32 @@ public static void AddRange<T>(this List<T> list, ReadOnlySpan<T> source)
         {
             if (!source.IsEmpty)
             {
-                ref var view = ref Unsafe.As<List<T>, CollectionsMarshal.ListView<T>>(ref list!);
-
-                if (view._items.Length - view._size < source.Length)
-                {
-                    Grow(ref view, checked(view._size + source.Length));
+                if (!CollectionsMarshal.IsLegacyList)
+                {
+                    ref var view = ref Unsafe.As<List<T>, CollectionsMarshal.ListView<T>>(ref list!);
+
+                    if (view._items.Length - view._size < source.Length)
+                    {
+                        Grow(ref view._items, view._size, checked(view._size + source.Length));
+                    }
+
+                    source.CopyTo(view._items.AsSpan(view._size));
+                    view._size += source.Length;
+                    view._version++;
+                }
+                else
+                {
+                    ref var view = ref Unsafe.As<List<T>, CollectionsMarshal.LegacyListView<T>>(ref list!);
+
+                    if (view._items.Length - view._size < source.Length)
+                    {
+                        Grow(ref view._items, view._size, checked(view._size + source.Length));
+                    }
+
+                    source.CopyTo(view._items.AsSpan(view._size));
+                    view._size += source.Length;
+                    view._version++;
                 }
-
-                source.CopyTo(view._items.AsSpan(view._size));
-                view._size += source.Length;
-                view._version++;
             }
         }
 
@@ -62,53 +78,74 @@ public static void AddRange<T>(this List<T> list, ReadOnlySpan<T> source)
         public static void InsertRange<T>(this List<T> list, int index, ReadOnlySpan<T> source)
         {
             if (!source.IsEmpty)
-            {
-                ref var view = ref Unsafe.As<List<T>, CollectionsMarshal.ListView<T>>(ref list!);
-
-                if (view._items.Length - view._size < source.Length)
-                {
-                    Grow(ref view, checked(view._size + source.Length));
+            {
+                if (!CollectionsMarshal.IsLegacyList)
+                {
+                    ref var view = ref Unsafe.As<List<T>, CollectionsMarshal.ListView<T>>(ref list!);
+
+                    if (view._items.Length - view._size < source.Length)
+                    {
+                        Grow(ref view._items, view._size, checked(view._size + source.Length));
+                    }
+
+                    if (index < view._size)
+                    {
+                        Array.Copy(view._items, index, view._items, index + source.Length, view._size - index);
+                    }
+
+                    source.CopyTo(view._items.AsSpan(index));
+                    view._size += source.Length;
+                    view._version++;
+                }
+                else
+                {
+                    ref var view = ref Unsafe.As<List<T>, CollectionsMarshal.LegacyListView<T>>(ref list!);
+
+                    if (view._items.Length - view._size < source.Length)
+                    {
+                        Grow(ref view._items, view._size, checked(view._size + source.Length));
+                    }
+
+                    if (index < view._size)
+                    {
+                        Array.Copy(view._items, index, view._items, index + source.Length, view._size - index);
+                    }
+
+                    source.CopyTo(view._items.AsSpan(index));
+                    view._size += source.Length;
+                    view._version++;
                 }
-
-                if (index < view._size)
-                {
-                    Array.Copy(view._items, index, view._items, index + source.Length, view._size - index);
-                }
-
-                source.CopyTo(view._items.AsSpan(index));
-                view._size += source.Length;
-                view._version++;
             }
-        }
-
-        static void Grow<T>(ref CollectionsMarshal.ListView<T> list, int capacity)
+        }
+
+        static void Grow<T>(ref T[] items, int size, int capacity)
         {
-            SetCapacity(ref list, GetNewCapacity(ref list, capacity));
-        }
-
-        static void SetCapacity<T>(ref CollectionsMarshal.ListView<T> list, int value)
+            SetCapacity(ref items, size, GetNewCapacity(items.Length, capacity));
+        }
+
+        static void SetCapacity<T>(ref T[] items, int size, int capacity)
         {
-            if (value != list._items.Length)
+            if (capacity != items.Length)
             {
-                if (value > 0)
+                if (capacity > 0)
                 {
-                    T[] newItems = new T[value];
-                    if (list._size > 0)
+                    T[] newItems = new T[capacity];
+                    if (size > 0)
                     {
-                        Array.Copy(list._items, newItems, list._size);
+                        Array.Copy(items, newItems, size);
                     }
-                    list._items = newItems;
+                    items = newItems;
                 }
                 else
                 {
-                    list._items = Array.Empty<T>();
+                    items = Array.Empty<T>();
                 }
             }
-        }
-
-        static int GetNewCapacity<T>(ref CollectionsMarshal.ListView<T> list, int capacity)
+        }
+
+        static int GetNewCapacity(int length, int capacity)
         {
-            int newCapacity = list._items.Length == 0 ? 4 : 2 * list._items.Length;
+            int newCapacity = length == 0 ? 4 : 2 * length;
 
             if ((uint)newCapacity > ArrayMaxLength) newCapacity = ArrayMaxLength;
 
diff --git a/src/ObservableCollections/Shims/CollectionsMarshalEx.cs b/src/ObservableCollections/Shims/CollectionsMarshalEx.cs
index 6541623..f58fb71 100644
--- a/src/ObservableCollections/Shims/CollectionsMarshalEx.cs
+++ b/src/ObservableCollections/Shims/CollectionsMarshalEx.cs
@@ -12,23 +12,59 @@ namespace System.Runtime.InteropServices;
 
 internal static class CollectionsMarshal
 {
+    internal static readonly bool IsLegacyList;
+
+#if NETSTANDARD2_0 || NETSTANDARD2_1
+    static CollectionsMarshal()
+    {
+        int listSize = 0;
+        try
+        {
+            listSize = typeof(List<>).GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).Length;
+        }
+        catch
+        {
+            listSize = 3;
+        }
+
+        // In .NET Framework, List<T> has a _syncRoot field, so the number of fields becomes 4.
+        IsLegacyList = listSize == 4;
+    }
+#endif
+
     /// <summary>
     /// similar as AsSpan but modify size to create fixed-size span.
     /// </summary>
     public static Span<T> AsSpan<T>(List<T>? list)
     {
-        if (list is null) return default;
-
-        ref var view = ref Unsafe.As<List<T>, ListView<T>>(ref list!);
-        return view._items.AsSpan(0, view._size);
-    }
-
+        if (list is null) return default;
+
+        if (IsLegacyList)
+        {
+            ref var view = ref Unsafe.As<List<T>, LegacyListView<T>>(ref list!);
+            return view._items.AsSpan(0, list.Count);
+        }
+        else
+        {
+            ref var view = ref Unsafe.As<List<T>, ListView<T>>(ref list!);
+            return view._items.AsSpan(0, list.Count);
+        }
+    }
+
     internal sealed class ListView<T>
     {
         public T[] _items;
         public int _size;
         public int _version;
+    }
+
+    internal sealed class LegacyListView<T>
+    {
+        public T[] _items;
+        public int _size;
+        public int _version;
+        public Object _syncRoot; // in .NET Framework
     }
 }
 
-#endif
\ No newline at end of file
+#endif