diff --git a/src/libraries/Common/tests/System/Collections/TestBase.Generic.cs b/src/libraries/Common/tests/System/Collections/TestBase.Generic.cs
index 44c272dbd933f3..3769da939c0e6e 100644
--- a/src/libraries/Common/tests/System/Collections/TestBase.Generic.cs
+++ b/src/libraries/Common/tests/System/Collections/TestBase.Generic.cs
@@ -37,42 +37,49 @@ public abstract class TestBase<T> : TestBase
         /// MemberData to be passed to tests that take an IEnumerable{T}. This method returns every permutation of
         /// EnumerableType to test on (e.g. HashSet, Queue), and size of set to test with (e.g. 0, 1, etc.).
         /// </summary>
-        public static IEnumerable<object[]> EnumerableTestData()
+        public static IEnumerable<object[]> EnumerableTestData() =>
+            ((IEnumerable<EnumerableType>)Enum.GetValues(typeof(EnumerableType))).SelectMany(GetEnumerableTestData);
+
+        /// <summary>
+        /// MemberData to be passed to tests that take an IEnumerable{T}. This method returns results for various
+        /// sizes of sets to test with (e.g. 0, 1, etc.) but only for List.
+        /// </summary>
+        public static IEnumerable<object[]> ListTestData() =>
+            GetEnumerableTestData(EnumerableType.List);
+
+        private static IEnumerable<object[]> GetEnumerableTestData(EnumerableType enumerableType)
         {
             foreach (object[] collectionSizeArray in ValidCollectionSizes())
             {
-                foreach (EnumerableType enumerableType in Enum.GetValues(typeof(EnumerableType)))
+                int count = (int)collectionSizeArray[0];
+                yield return new object[] { enumerableType, count, 0, 0, 0 };                       // Empty Enumerable
+                yield return new object[] { enumerableType, count, count + 1, 0, 0 };               // Enumerable that is 1 larger
+
+                if (count >= 1)
+                {
+                    yield return new object[] { enumerableType, count, count, 0, 0 };               // Enumerable of the same size
+                    yield return new object[] { enumerableType, count, count - 1, 0, 0 };           // Enumerable that is 1 smaller
+                    yield return new object[] { enumerableType, count, count, 1, 0 };               // Enumerable of the same size with 1 matching element
+                    yield return new object[] { enumerableType, count, count + 1, 1, 0 };           // Enumerable that is 1 longer with 1 matching element
+                    yield return new object[] { enumerableType, count, count, count, 0 };           // Enumerable with all elements matching
+                    yield return new object[] { enumerableType, count, count + 1, count, 0 };       // Enumerable with all elements matching plus one extra
+                }
+
+                if (count >= 2)
+                {
+                    yield return new object[] { enumerableType, count, count - 1, 1, 0 };           // Enumerable that is 1 smaller with 1 matching element
+                    yield return new object[] { enumerableType, count, count + 2, 2, 0 };           // Enumerable that is 2 longer with 2 matching element
+                    yield return new object[] { enumerableType, count, count - 1, count - 1, 0 };   // Enumerable with all elements matching minus one
+                    yield return new object[] { enumerableType, count, count, 2, 0 };               // Enumerable of the same size with 2 matching element
+                    if ((enumerableType == EnumerableType.List || enumerableType == EnumerableType.Queue))
+                        yield return new object[] { enumerableType, count, count, 0, 1 };           // Enumerable with 1 element duplicated
+                }
+
+                if (count >= 3)
                 {
-                    int count = (int)collectionSizeArray[0];
-                    yield return new object[] { enumerableType, count, 0, 0, 0 };                       // Empty Enumerable
-                    yield return new object[] { enumerableType, count, count + 1, 0, 0 };               // Enumerable that is 1 larger
-
-                    if (count >= 1)
-                    {
-                        yield return new object[] { enumerableType, count, count, 0, 0 };               // Enumerable of the same size
-                        yield return new object[] { enumerableType, count, count - 1, 0, 0 };           // Enumerable that is 1 smaller
-                        yield return new object[] { enumerableType, count, count, 1, 0 };               // Enumerable of the same size with 1 matching element
-                        yield return new object[] { enumerableType, count, count + 1, 1, 0 };           // Enumerable that is 1 longer with 1 matching element
-                        yield return new object[] { enumerableType, count, count, count, 0 };           // Enumerable with all elements matching
-                        yield return new object[] { enumerableType, count, count + 1, count, 0 };       // Enumerable with all elements matching plus one extra
-                    }
-
-                    if (count >= 2)
-                    {
-                        yield return new object[] { enumerableType, count, count - 1, 1, 0 };           // Enumerable that is 1 smaller with 1 matching element
-                        yield return new object[] { enumerableType, count, count + 2, 2, 0 };           // Enumerable that is 2 longer with 2 matching element
-                        yield return new object[] { enumerableType, count, count - 1, count - 1, 0 };   // Enumerable with all elements matching minus one
-                        yield return new object[] { enumerableType, count, count, 2, 0 };               // Enumerable of the same size with 2 matching element
-                        if ((enumerableType == EnumerableType.List || enumerableType == EnumerableType.Queue))
-                            yield return new object[] { enumerableType, count, count, 0, 1 };           // Enumerable with 1 element duplicated
-                    }
-
-                    if (count >= 3)
-                    {
-                        if ((enumerableType == EnumerableType.List || enumerableType == EnumerableType.Queue))
-                            yield return new object[] { enumerableType, count, count, 0, 1 };           // Enumerable with all elements duplicated
-                        yield return new object[] { enumerableType, count, count - 1, 2, 0 };           // Enumerable that is 1 smaller with 2 matching elements
-                    }
+                    if ((enumerableType == EnumerableType.List || enumerableType == EnumerableType.Queue))
+                        yield return new object[] { enumerableType, count, count, 0, 1 };           // Enumerable with all elements duplicated
+                    yield return new object[] { enumerableType, count, count - 1, 2, 0 };           // Enumerable that is 1 smaller with 2 matching elements
                 }
             }
         }
diff --git a/src/libraries/System.Collections/ref/System.Collections.cs b/src/libraries/System.Collections/ref/System.Collections.cs
index 4c5dc875d17181..755cabad1748cc 100644
--- a/src/libraries/System.Collections/ref/System.Collections.cs
+++ b/src/libraries/System.Collections/ref/System.Collections.cs
@@ -42,15 +42,6 @@ public static partial class StructuralComparisons
 }
 namespace System.Collections.Generic
 {
-    public static partial class CollectionExtensions
-    {
-        public static TValue? GetValueOrDefault<TKey, TValue>(this System.Collections.Generic.IReadOnlyDictionary<TKey, TValue> dictionary, TKey key) { throw null; }
-        public static TValue GetValueOrDefault<TKey, TValue>(this System.Collections.Generic.IReadOnlyDictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue) { throw null; }
-        public static bool Remove<TKey, TValue>(this System.Collections.Generic.IDictionary<TKey, TValue> dictionary, TKey key, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TValue value) { throw null; }
-        public static bool TryAdd<TKey, TValue>(this System.Collections.Generic.IDictionary<TKey, TValue> dictionary, TKey key, TValue value) { throw null; }
-        public static System.Collections.ObjectModel.ReadOnlyCollection<T> AsReadOnly<T>(this IList<T> list) { throw null; }
-        public static System.Collections.ObjectModel.ReadOnlyDictionary<TKey, TValue> AsReadOnly<TKey, TValue>(this IDictionary<TKey, TValue> dictionary) where TKey : notnull { throw null; }
-    }
     public sealed partial class LinkedListNode<T>
     {
         public LinkedListNode(T value) { }
@@ -411,6 +402,18 @@ void System.Collections.IEnumerator.Reset() { }
 #endif // !BUILDING_CORELIB_REFERENCE
 namespace System.Collections.Generic
 {
+    public static partial class CollectionExtensions
+    {
+        public static void AddRange<T>(this System.Collections.Generic.List<T> list, System.ReadOnlySpan<T> source) { }
+        public static void CopyTo<T>(this System.Collections.Generic.List<T> list, System.Span<T> destination) { }
+        public static TValue? GetValueOrDefault<TKey, TValue>(this System.Collections.Generic.IReadOnlyDictionary<TKey, TValue> dictionary, TKey key) { throw null; }
+        public static TValue GetValueOrDefault<TKey, TValue>(this System.Collections.Generic.IReadOnlyDictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue) { throw null; }
+        public static void InsertRange<T>(this System.Collections.Generic.List<T> list, int index, System.ReadOnlySpan<T> source) { }
+        public static bool Remove<TKey, TValue>(this System.Collections.Generic.IDictionary<TKey, TValue> dictionary, TKey key, [System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute(false)] out TValue value) { throw null; }
+        public static bool TryAdd<TKey, TValue>(this System.Collections.Generic.IDictionary<TKey, TValue> dictionary, TKey key, TValue value) { throw null; }
+        public static System.Collections.ObjectModel.ReadOnlyCollection<T> AsReadOnly<T>(this IList<T> list) { throw null; }
+        public static System.Collections.ObjectModel.ReadOnlyDictionary<TKey, TValue> AsReadOnly<TKey, TValue>(this IDictionary<TKey, TValue> dictionary) where TKey : notnull { throw null; }
+    }
     public abstract partial class Comparer<T> : System.Collections.Generic.IComparer<T>, System.Collections.IComparer
     {
         protected Comparer() { }
diff --git a/src/libraries/System.Collections/src/System.Collections.csproj b/src/libraries/System.Collections/src/System.Collections.csproj
index 7c570c8364aadd..102ab0ee950ddf 100644
--- a/src/libraries/System.Collections/src/System.Collections.csproj
+++ b/src/libraries/System.Collections/src/System.Collections.csproj
@@ -7,7 +7,6 @@
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="System\Collections\BitArray.cs" />
-    <Compile Include="System\Collections\Generic\CollectionExtensions.cs" />
     <Compile Include="$(CoreLibSharedDir)System\Collections\Generic\ICollectionDebugView.cs"
              Link="Common\System\Collections\Generic\ICollectionDebugView.cs" />
     <Compile Include="$(CoreLibSharedDir)System\Collections\Generic\IDictionaryDebugView.cs"
diff --git a/src/libraries/System.Collections/src/System/Collections/Generic/CollectionExtensions.cs b/src/libraries/System.Collections/src/System/Collections/Generic/CollectionExtensions.cs
deleted file mode 100644
index d8523aab82d6db..00000000000000
--- a/src/libraries/System.Collections/src/System/Collections/Generic/CollectionExtensions.cs
+++ /dev/null
@@ -1,78 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.Collections.ObjectModel;
-using System.Diagnostics.CodeAnalysis;
-
-namespace System.Collections.Generic
-{
-    public static class CollectionExtensions
-    {
-        public static TValue? GetValueOrDefault<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary, TKey key)
-        {
-            return dictionary.GetValueOrDefault(key, default!);
-        }
-
-        public static TValue GetValueOrDefault<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue)
-        {
-            ArgumentNullException.ThrowIfNull(dictionary);
-
-            TValue? value;
-            return dictionary.TryGetValue(key, out value) ? value : defaultValue;
-        }
-
-        public static bool TryAdd<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, TValue value)
-        {
-            ArgumentNullException.ThrowIfNull(dictionary);
-
-            if (!dictionary.ContainsKey(key))
-            {
-                dictionary.Add(key, value);
-                return true;
-            }
-
-            return false;
-        }
-
-        public static bool Remove<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, [MaybeNullWhen(false)] out TValue value)
-        {
-            ArgumentNullException.ThrowIfNull(dictionary);
-
-            if (dictionary.TryGetValue(key, out value))
-            {
-                dictionary.Remove(key);
-                return true;
-            }
-
-            value = default;
-            return false;
-        }
-
-        /// <summary>
-        /// Returns a read-only <see cref="ReadOnlyCollection{T}"/> wrapper
-        /// for the specified list.
-        /// </summary>
-        /// <typeparam name="T">The type of elements in the collection.</typeparam>
-        /// <param name="list">The list to wrap.</param>
-        /// <returns>An object that acts as a read-only wrapper around the current <see cref="IList{T}"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="list"/> is null.</exception>
-        public static ReadOnlyCollection<T> AsReadOnly<T>(this IList<T> list)
-        {
-            return new ReadOnlyCollection<T>(list);
-        }
-
-        /// <summary>
-        /// Returns a read-only <see cref="ReadOnlyDictionary{TKey, TValue}"/> wrapper
-        /// for the current dictionary.
-        /// </summary>
-        /// <typeparam name="TKey">The type of keys in the dictionary.</typeparam>
-        /// <typeparam name="TValue">The type of values in the dictionary.</typeparam>
-        /// <param name="dictionary">The dictionary to wrap.</param>
-        /// <returns>An object that acts as a read-only wrapper around the current <see cref="IDictionary{TKey, TValue}"/>.</returns>
-        /// <exception cref="ArgumentNullException"><paramref name="dictionary"/> is null.</exception>
-        public static ReadOnlyDictionary<TKey, TValue> AsReadOnly<TKey, TValue>(this IDictionary<TKey, TValue> dictionary) where TKey : notnull
-        {
-            return new ReadOnlyDictionary<TKey, TValue>(dictionary);
-        }
-    }
-}
diff --git a/src/libraries/System.Collections/tests/Generic/List/List.Generic.Tests.AddRange.cs b/src/libraries/System.Collections/tests/Generic/List/List.Generic.Tests.AddRange.cs
index 0344a57c4717da..26298c68791107 100644
--- a/src/libraries/System.Collections/tests/Generic/List/List.Generic.Tests.AddRange.cs
+++ b/src/libraries/System.Collections/tests/Generic/List/List.Generic.Tests.AddRange.cs
@@ -36,6 +36,35 @@ public void AddRange(EnumerableType enumerableType, int listLength, int enumerab
             });
         }
 
+        [Theory]
+        [MemberData(nameof(ListTestData))]
+        public void AddRange_Span(EnumerableType enumerableType, int listLength, int enumerableLength, int numberOfMatchingElements, int numberOfDuplicateElements)
+        {
+            List<T> list = GenericListFactory(listLength);
+            List<T> listBeforeAdd = list.ToList();
+            Span<T> span = CreateEnumerable(enumerableType, list, enumerableLength, numberOfMatchingElements, numberOfDuplicateElements).ToArray();
+            list.AddRange(span);
+
+            // Check that the first section of the List is unchanged
+            Assert.All(Enumerable.Range(0, listLength), index =>
+            {
+                Assert.Equal(listBeforeAdd[index], list[index]);
+            });
+
+            // Check that the added elements are correct
+            for (int i = 0; i < enumerableLength; i++)
+            {
+                Assert.Equal(span[i], list[i + listLength]);
+            };
+        }
+
+        [Fact]
+        public void AddRange_NullList_ThrowsArgumentNullException()
+        {
+            AssertExtensions.Throws<ArgumentNullException>("list", () => CollectionExtensions.AddRange<int>(null, default));
+            AssertExtensions.Throws<ArgumentNullException>("list", () => CollectionExtensions.AddRange<int>(null, new int[1]));
+        }
+
         [Theory]
         [MemberData(nameof(ValidCollectionSizes))]
         public void AddRange_NullEnumerable_ThrowsArgumentNullException(int count)
diff --git a/src/libraries/System.Collections/tests/Generic/List/List.Generic.Tests.CopyTo.cs b/src/libraries/System.Collections/tests/Generic/List/List.Generic.Tests.CopyTo.cs
new file mode 100644
index 00000000000000..70bc155835ab1f
--- /dev/null
+++ b/src/libraries/System.Collections/tests/Generic/List/List.Generic.Tests.CopyTo.cs
@@ -0,0 +1,45 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using Xunit;
+
+namespace System.Collections.Tests
+{
+    /// <summary>
+    /// Contains tests that ensure the correctness of the List class.
+    /// </summary>
+    public abstract partial class List_Generic_Tests<T> : IList_Generic_Tests<T>
+    {
+        [Fact]
+        public void CopyTo_InvalidArgs_Throws()
+        {
+            AssertExtensions.Throws<ArgumentNullException>("list", () => CollectionExtensions.CopyTo(null, Span<int>.Empty));
+            AssertExtensions.Throws<ArgumentNullException>("list", () => CollectionExtensions.CopyTo(null, new Span<int>(new int[1])));
+
+            var list = new List<int>() { 1, 2, 3 };
+            Assert.Throws<ArgumentException>(() => CollectionExtensions.CopyTo(list, (Span<int>)new int[2]));
+        }
+
+        [Fact]
+        public void CopyTo_ItemsCopiedCorrectly()
+        {
+            List<int> list;
+            Span<int> destination;
+
+            list = new List<int>();
+            destination = Span<int>.Empty;
+            list.CopyTo(destination);
+
+            list = new List<int>() { 1, 2, 3 };
+            destination = new int[3];
+            list.CopyTo(destination);
+            Assert.Equal(new[] { 1, 2, 3 }, destination.ToArray());
+
+            list = new List<int>() { 1, 2, 3 };
+            destination = new int[4];
+            list.CopyTo(destination);
+            Assert.Equal(new[] { 1, 2, 3, 0 }, destination.ToArray());
+        }
+    }
+}
diff --git a/src/libraries/System.Collections/tests/Generic/List/List.Generic.Tests.InsertRange.cs b/src/libraries/System.Collections/tests/Generic/List/List.Generic.Tests.InsertRange.cs
new file mode 100644
index 00000000000000..d72fd45dd00cc9
--- /dev/null
+++ b/src/libraries/System.Collections/tests/Generic/List/List.Generic.Tests.InsertRange.cs
@@ -0,0 +1,51 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace System.Collections.Tests
+{
+    /// <summary>
+    /// Contains tests that ensure the correctness of the List class.
+    /// </summary>
+    public abstract partial class List_Generic_Tests<T> : IList_Generic_Tests<T>
+    {
+        [Fact]
+        public void InsertRange_InvalidArgs_Throws()
+        {
+            AssertExtensions.Throws<ArgumentNullException>("list", () => CollectionExtensions.InsertRange(null, 0, ReadOnlySpan<int>.Empty));
+            AssertExtensions.Throws<ArgumentNullException>("list", () => CollectionExtensions.InsertRange(null, 0, new ReadOnlySpan<int>(new int[1])));
+
+            var list = new List<int>();
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("index", () => CollectionExtensions.InsertRange(list, 1, new int[0]));
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("index", () => CollectionExtensions.InsertRange(list, -1, new int[0]));
+        }
+
+        [Fact]
+        public void InsertRange_MatchesExpectedContents()
+        {
+            var list = new List<int>();
+
+            list.InsertRange(0, ReadOnlySpan<int>.Empty);
+            Assert.Equal(0, list.Count);
+
+            list.InsertRange(0, (ReadOnlySpan<int>)new int[] { 3, 2, 1 });
+            Assert.Equal(3, list.Count);
+            Assert.Equal(new[] { 3, 2, 1 }, list);
+
+            list.InsertRange(0, (ReadOnlySpan<int>)new int[] { 6, 5, 4 });
+            Assert.Equal(6, list.Count);
+            Assert.Equal(new[] { 6, 5, 4, 3, 2, 1 }, list);
+
+            list.InsertRange(6, (ReadOnlySpan<int>)new int[] { 0, -1, -2 });
+            Assert.Equal(9, list.Count);
+            Assert.Equal(new[] { 6, 5, 4, 3, 2, 1, 0, -1, -2 }, list);
+
+            list.InsertRange(3, (ReadOnlySpan<int>)new int[] { 100, 99, 98 });
+            Assert.Equal(12, list.Count);
+            Assert.Equal(new[] { 6, 5, 4, 100, 99, 98, 3, 2, 1, 0, -1, -2 }, list);
+        }
+    }
+}
diff --git a/src/libraries/System.Collections/tests/System.Collections.Tests.csproj b/src/libraries/System.Collections/tests/System.Collections.Tests.csproj
index 3855b43bfa6d9a..2187dff4f7c759 100644
--- a/src/libraries/System.Collections/tests/System.Collections.Tests.csproj
+++ b/src/libraries/System.Collections/tests/System.Collections.Tests.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFramework>$(NetCoreAppCurrent)</TargetFramework>
     <TestRuntime>true</TestRuntime>
@@ -98,8 +98,10 @@
     <Compile Include="Generic\List\List.Generic.Tests.BinarySearch.cs" />
     <Compile Include="Generic\List\List.Generic.Tests.Constructor.cs" />
     <Compile Include="Generic\List\List.Generic.Tests.ConvertAll.cs" />
+    <Compile Include="Generic\List\List.Generic.Tests.CopyTo.cs" />
     <Compile Include="Generic\List\List.Generic.Tests.Find.cs" />
     <Compile Include="Generic\List\List.Generic.Tests.EnsureCapacity.cs" />
+    <Compile Include="Generic\List\List.Generic.Tests.InsertRange.cs" />
     <Compile Include="Generic\List\List.Generic.Tests.Remove.cs" />
     <Compile Include="Generic\List\List.Generic.Tests.Sort.cs" />
     <Compile Include="Generic\PriorityQueue\PriorityQueue.Generic.cs" />
diff --git a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
index d8620637574c08..e4f97a37356299 100644
--- a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
+++ b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems
@@ -187,6 +187,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Collections\Concurrent\IProducerConsumerCollectionDebugView.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Collections\DictionaryEntry.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Collections\Generic\ArraySortHelper.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Collections\Generic\CollectionExtensions.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Collections\Generic\Comparer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Collections\Generic\Dictionary.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Collections\Generic\EqualityComparer.cs" />
diff --git a/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/CollectionExtensions.cs b/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/CollectionExtensions.cs
new file mode 100644
index 00000000000000..068536049a65f9
--- /dev/null
+++ b/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/CollectionExtensions.cs
@@ -0,0 +1,164 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.ObjectModel;
+using System.Diagnostics.CodeAnalysis;
+
+namespace System.Collections.Generic
+{
+    public static class CollectionExtensions
+    {
+        public static TValue? GetValueOrDefault<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary, TKey key) =>
+            dictionary.GetValueOrDefault(key, default!);
+
+        public static TValue GetValueOrDefault<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue)
+        {
+            if (dictionary is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
+            }
+
+            return dictionary.TryGetValue(key, out TValue? value) ? value : defaultValue;
+        }
+
+        public static bool TryAdd<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, TValue value)
+        {
+            if (dictionary is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
+            }
+
+            if (!dictionary.ContainsKey(key))
+            {
+                dictionary.Add(key, value);
+                return true;
+            }
+
+            return false;
+        }
+
+        public static bool Remove<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, [MaybeNullWhen(false)] out TValue value)
+        {
+            if (dictionary is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);
+            }
+
+            if (dictionary.TryGetValue(key, out value))
+            {
+                dictionary.Remove(key);
+                return true;
+            }
+
+            value = default;
+            return false;
+        }
+
+        /// <summary>
+        /// Returns a read-only <see cref="ReadOnlyCollection{T}"/> wrapper
+        /// for the specified list.
+        /// </summary>
+        /// <typeparam name="T">The type of elements in the collection.</typeparam>
+        /// <param name="list">The list to wrap.</param>
+        /// <returns>An object that acts as a read-only wrapper around the current <see cref="IList{T}"/>.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="list"/> is null.</exception>
+        public static ReadOnlyCollection<T> AsReadOnly<T>(this IList<T> list) =>
+            new ReadOnlyCollection<T>(list);
+
+        /// <summary>
+        /// Returns a read-only <see cref="ReadOnlyDictionary{TKey, TValue}"/> wrapper
+        /// for the current dictionary.
+        /// </summary>
+        /// <typeparam name="TKey">The type of keys in the dictionary.</typeparam>
+        /// <typeparam name="TValue">The type of values in the dictionary.</typeparam>
+        /// <param name="dictionary">The dictionary to wrap.</param>
+        /// <returns>An object that acts as a read-only wrapper around the current <see cref="IDictionary{TKey, TValue}"/>.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="dictionary"/> is null.</exception>
+        public static ReadOnlyDictionary<TKey, TValue> AsReadOnly<TKey, TValue>(this IDictionary<TKey, TValue> dictionary) where TKey : notnull =>
+            new ReadOnlyDictionary<TKey, TValue>(dictionary);
+
+        /// <summary>Adds the elements of the specified span to the end of the <see cref="List{T}"/>.</summary>
+        /// <typeparam name="T">The type of elements in the list.</typeparam>
+        /// <param name="list">The list to which the elements should be added.</param>
+        /// <param name="source">The span whose elements should be added to the end of the <see cref="List{T}"/>.</param>
+        /// <exception cref="ArgumentNullException">The <paramref name="list"/> is null.</exception>
+        public static void AddRange<T>(this List<T> list, ReadOnlySpan<T> source)
+        {
+            if (list is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.list);
+            }
+
+            if (!source.IsEmpty)
+            {
+                if (list._items.Length - list._size < source.Length)
+                {
+                    list.Grow(checked(list._size + source.Length));
+                }
+
+                source.CopyTo(list._items.AsSpan(list._size));
+                list._size += source.Length;
+                list._version++;
+            }
+        }
+
+        /// <summary>Inserts the elements of a span into the <see cref="List{T}"/> at the specified index.</summary>
+        /// <typeparam name="T">The type of elements in the list.</typeparam>
+        /// <param name="list">The list into which the elements should be inserted.</param>
+        /// <param name="index">The zero-based index at which the new elements should be inserted.</param>
+        /// <param name="source">The span whose elements should be added to the <see cref="List{T}"/>.</param>
+        /// <exception cref="ArgumentNullException">The <paramref name="list"/> is null.</exception>
+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="index"/> is less than 0 or greater than <paramref name="list"/>'s <see cref="List{T}.Count"/>.</exception>
+        public static void InsertRange<T>(this List<T> list, int index, ReadOnlySpan<T> source)
+        {
+            if (list is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.list);
+            }
+
+            if ((uint)index > (uint)list._size)
+            {
+                ThrowHelper.ThrowArgumentOutOfRange_IndexMustBeLessOrEqualException();
+            }
+
+            if (!source.IsEmpty)
+            {
+                if (list._items.Length - list._size < source.Length)
+                {
+                    list.Grow(checked(list._size + source.Length));
+                }
+
+                // If the index at which to insert is less than the number of items in the list,
+                // shift all items past that location in the list down to the end, making room
+                // to copy in the new data.
+                if (index < list._size)
+                {
+                    Array.Copy(list._items, index, list._items, index + source.Length, list._size - index);
+                }
+
+                // Copy the source span into the list.
+                // Note that this does not handle the unsafe case of trying to insert a CollectionsMarshal.AsSpan(list)
+                // or some slice thereof back into the list itself; such an operation has undefined behavior.
+                source.CopyTo(list._items.AsSpan(index));
+                list._size += source.Length;
+                list._version++;
+            }
+        }
+
+        /// <summary>Copies the entire <see cref="List{T}"/> to a span.</summary>
+        /// <typeparam name="T">The type of elements in the list.</typeparam>
+        /// <param name="list">The list from which the elements are copied.</param>
+        /// <param name="destination">The span that is the destination of the elements copied from <paramref name="list"/>.</param>
+        /// <exception cref="ArgumentNullException">The <paramref name="list"/> is null.</exception>
+        /// <exception cref="ArgumentException">The number of elements in the source <see cref="List{T}"/> is greater than the number of elements that the destination span can contain.</exception>
+        public static void CopyTo<T>(this List<T> list, Span<T> destination)
+        {
+            if (list is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.list);
+            }
+
+            new ReadOnlySpan<T>(list._items, 0, list._size).CopyTo(destination);
+        }
+    }
+}
diff --git a/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/List.cs b/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/List.cs
index 8db8b83861ae72..6f1340e318fb5a 100644
--- a/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/List.cs
+++ b/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/List.cs
@@ -24,7 +24,7 @@ public class List<T> : IList<T>, IList, IReadOnlyList<T>
 
         internal T[] _items; // Do not rename (binary serialization)
         internal int _size; // Do not rename (binary serialization)
-        private int _version; // Do not rename (binary serialization)
+        internal int _version; // Do not rename (binary serialization)
 
 #pragma warning disable CA1825 // avoid the extra generic instantiation for Array.Empty<T>()
         private static readonly T[] s_emptyArray = new T[0];
@@ -449,7 +449,7 @@ public int EnsureCapacity(int capacity)
         /// Increase the capacity of this list to at least the specified <paramref name="capacity"/>.
         /// </summary>
         /// <param name="capacity">The minimum capacity to ensure.</param>
-        private void Grow(int capacity)
+        internal void Grow(int capacity)
         {
             Debug.Assert(_items.Length < capacity);