diff --git a/.editorconfig b/.editorconfig
index 36629f6b744..d10fc7eea1f 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -327,4 +327,4 @@ dotnet_diagnostic.SA1413.severity = none # UseTrailingCommasInMultiLineInitializ
 dotnet_diagnostic.SA1314.severity = none # TypeParameterNamesMustBeginWithT: We do have a few templates that don't start with T. We need to double check that changing this is not a breaking change. If not, we can re-enable this.
 dotnet_diagnostic.SA1000.severity = none # Hide warnings when using the new() expression from C# 9.
 dotnet_diagnostic.SA1313.severity = none # Hide warnings for record parameters.
-dotnet_diagnostic.SA1101.severity = none # Hide warnings when accessing properties without "this".
\ No newline at end of file
+dotnet_diagnostic.SA1101.severity = none # Hide warnings when accessing properties without "this".
diff --git a/Microsoft.Toolkit.HighPerformance/Buffers/MemoryOwner{T}.cs b/Microsoft.Toolkit.HighPerformance/Buffers/MemoryOwner{T}.cs
index da8234dc070..174f3a4b613 100644
--- a/Microsoft.Toolkit.HighPerformance/Buffers/MemoryOwner{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/Buffers/MemoryOwner{T}.cs
@@ -91,7 +91,7 @@ private MemoryOwner(int start, int length, ArrayPool<T> pool, T[] array)
         public static MemoryOwner<T> Empty
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => new MemoryOwner<T>(0, ArrayPool<T>.Shared, AllocationMode.Default);
+            get => new(0, ArrayPool<T>.Shared, AllocationMode.Default);
         }
 
         /// <summary>
@@ -103,7 +103,7 @@ public static MemoryOwner<T> Empty
         /// <remarks>This method is just a proxy for the <see langword="private"/> constructor, for clarity.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static MemoryOwner<T> Allocate(int size) => new MemoryOwner<T>(size, ArrayPool<T>.Shared, AllocationMode.Default);
+        public static MemoryOwner<T> Allocate(int size) => new(size, ArrayPool<T>.Shared, AllocationMode.Default);
 
         /// <summary>
         /// Creates a new <see cref="MemoryOwner{T}"/> instance with the specified parameters.
@@ -115,7 +115,7 @@ public static MemoryOwner<T> Empty
         /// <remarks>This method is just a proxy for the <see langword="private"/> constructor, for clarity.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static MemoryOwner<T> Allocate(int size, ArrayPool<T> pool) => new MemoryOwner<T>(size, pool, AllocationMode.Default);
+        public static MemoryOwner<T> Allocate(int size, ArrayPool<T> pool) => new(size, pool, AllocationMode.Default);
 
         /// <summary>
         /// Creates a new <see cref="MemoryOwner{T}"/> instance with the specified parameters.
@@ -127,7 +127,7 @@ public static MemoryOwner<T> Empty
         /// <remarks>This method is just a proxy for the <see langword="private"/> constructor, for clarity.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static MemoryOwner<T> Allocate(int size, AllocationMode mode) => new MemoryOwner<T>(size, ArrayPool<T>.Shared, mode);
+        public static MemoryOwner<T> Allocate(int size, AllocationMode mode) => new(size, ArrayPool<T>.Shared, mode);
 
         /// <summary>
         /// Creates a new <see cref="MemoryOwner{T}"/> instance with the specified parameters.
@@ -140,7 +140,7 @@ public static MemoryOwner<T> Empty
         /// <remarks>This method is just a proxy for the <see langword="private"/> constructor, for clarity.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static MemoryOwner<T> Allocate(int size, ArrayPool<T> pool, AllocationMode mode) => new MemoryOwner<T>(size, pool, mode);
+        public static MemoryOwner<T> Allocate(int size, ArrayPool<T> pool, AllocationMode mode) => new(size, pool, mode);
 
         /// <summary>
         /// Gets the number of items in the current instance
diff --git a/Microsoft.Toolkit.HighPerformance/Buffers/SpanOwner{T}.cs b/Microsoft.Toolkit.HighPerformance/Buffers/SpanOwner{T}.cs
index 456d4401831..f7c3863eb5c 100644
--- a/Microsoft.Toolkit.HighPerformance/Buffers/SpanOwner{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/Buffers/SpanOwner{T}.cs
@@ -80,7 +80,7 @@ private SpanOwner(int length, ArrayPool<T> pool, AllocationMode mode)
         public static SpanOwner<T> Empty
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => new SpanOwner<T>(0, ArrayPool<T>.Shared, AllocationMode.Default);
+            get => new(0, ArrayPool<T>.Shared, AllocationMode.Default);
         }
 
         /// <summary>
@@ -92,7 +92,7 @@ public static SpanOwner<T> Empty
         /// <remarks>This method is just a proxy for the <see langword="private"/> constructor, for clarity.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static SpanOwner<T> Allocate(int size) => new SpanOwner<T>(size, ArrayPool<T>.Shared, AllocationMode.Default);
+        public static SpanOwner<T> Allocate(int size) => new(size, ArrayPool<T>.Shared, AllocationMode.Default);
 
         /// <summary>
         /// Creates a new <see cref="SpanOwner{T}"/> instance with the specified parameters.
@@ -104,7 +104,7 @@ public static SpanOwner<T> Empty
         /// <remarks>This method is just a proxy for the <see langword="private"/> constructor, for clarity.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static SpanOwner<T> Allocate(int size, ArrayPool<T> pool) => new SpanOwner<T>(size, pool, AllocationMode.Default);
+        public static SpanOwner<T> Allocate(int size, ArrayPool<T> pool) => new(size, pool, AllocationMode.Default);
 
         /// <summary>
         /// Creates a new <see cref="SpanOwner{T}"/> instance with the specified parameters.
@@ -116,7 +116,7 @@ public static SpanOwner<T> Empty
         /// <remarks>This method is just a proxy for the <see langword="private"/> constructor, for clarity.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static SpanOwner<T> Allocate(int size, AllocationMode mode) => new SpanOwner<T>(size, ArrayPool<T>.Shared, mode);
+        public static SpanOwner<T> Allocate(int size, AllocationMode mode) => new(size, ArrayPool<T>.Shared, mode);
 
         /// <summary>
         /// Creates a new <see cref="SpanOwner{T}"/> instance with the specified parameters.
@@ -129,7 +129,7 @@ public static SpanOwner<T> Empty
         /// <remarks>This method is just a proxy for the <see langword="private"/> constructor, for clarity.</remarks>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static SpanOwner<T> Allocate(int size, ArrayPool<T> pool, AllocationMode mode) => new SpanOwner<T>(size, pool, mode);
+        public static SpanOwner<T> Allocate(int size, ArrayPool<T> pool, AllocationMode mode) => new(size, pool, mode);
 
         /// <summary>
         /// Gets the number of items in the current instance
@@ -183,7 +183,7 @@ public Span<T> Span
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public ArraySegment<T> DangerousGetArray()
         {
-            return new ArraySegment<T>(array!, 0, this.length);
+            return new(array!, 0, this.length);
         }
 
         /// <summary>
diff --git a/Microsoft.Toolkit.HighPerformance/Buffers/StringPool.cs b/Microsoft.Toolkit.HighPerformance/Buffers/StringPool.cs
index bbd8f5f18fc..492cca7f1bc 100644
--- a/Microsoft.Toolkit.HighPerformance/Buffers/StringPool.cs
+++ b/Microsoft.Toolkit.HighPerformance/Buffers/StringPool.cs
@@ -137,7 +137,7 @@ static void FindFactors(int size, int factor, out int x, out int y)
         /// process. Since <see cref="StringPool"/> is thread-safe, the shared instance can be used
         /// concurrently by multiple threads without the need for manual synchronization.
         /// </remarks>
-        public static StringPool Shared { get; } = new StringPool();
+        public static StringPool Shared { get; } = new();
 
         /// <summary>
         /// Gets the total number of <see cref="string"/> that can be stored in the current instance.
diff --git a/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs b/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs
index 2eff0897662..d58dc41b622 100644
--- a/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs
@@ -10,6 +10,8 @@
 #endif
 using Microsoft.Toolkit.HighPerformance.Extensions;
 using Microsoft.Toolkit.HighPerformance.Helpers.Internals;
+using Microsoft.Toolkit.HighPerformance.Memory.Internals;
+
 #if !SPAN_RUNTIME_SUPPORT
 using RuntimeHelpers = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers;
 #endif
@@ -76,6 +78,32 @@ internal ReadOnlyRefEnumerable(in T reference, int length, int step)
             this.span = MemoryMarshal.CreateReadOnlySpan(ref Unsafe.AsRef(reference), length);
             this.step = step;
         }
+
+        /// <summary>
+        /// Creates a new instance of the <see cref="ReadOnlyRefEnumerable{T}"/> struct with the specified parameters.
+        /// </summary>
+        /// <param name="value">The reference to the first <typeparamref name="T"/> item to map.</param>
+        /// <param name="length">The number of items in the sequence.</param>
+        /// <param name="step">The distance between items in the sequence to enumerate.</param>
+        /// <returns>A <see cref="ReadOnlyRefEnumerable{T}"/> instance with the specified parameters.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown when one of the parameters are negative.</exception>
+        [Pure]
+        public static ReadOnlyRefEnumerable<T> DangerousCreate(in T value, int length, int step)
+        {
+            if (length < 0)
+            {
+                ThrowArgumentOutOfRangeExceptionForLength();
+            }
+
+            if (step < 0)
+            {
+                ThrowArgumentOutOfRangeExceptionForStep();
+            }
+
+            OverflowHelper.EnsureIsInNativeIntRange(length, 1, step);
+
+            return new ReadOnlyRefEnumerable<T>(in value, length, step);
+        }
 #else
         /// <summary>
         /// Initializes a new instance of the <see cref="ReadOnlyRefEnumerable{T}"/> struct.
@@ -360,6 +388,22 @@ public bool MoveNext()
             }
         }
 
+        /// <summary>
+        /// Throws an <see cref="ArgumentOutOfRangeException"/> when the "length" parameter is invalid.
+        /// </summary>
+        private static void ThrowArgumentOutOfRangeExceptionForLength()
+        {
+            throw new ArgumentOutOfRangeException("length");
+        }
+
+        /// <summary>
+        /// Throws an <see cref="ArgumentOutOfRangeException"/> when the "step" parameter is invalid.
+        /// </summary>
+        private static void ThrowArgumentOutOfRangeExceptionForStep()
+        {
+            throw new ArgumentOutOfRangeException("step");
+        }
+
         /// <summary>
         /// Throws an <see cref="ArgumentException"/> when the target span is too short.
         /// </summary>
diff --git a/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs b/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs
index fae37dc76fc..656bfe96210 100644
--- a/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs
@@ -10,7 +10,9 @@
 #endif
 using Microsoft.Toolkit.HighPerformance.Extensions;
 using Microsoft.Toolkit.HighPerformance.Helpers.Internals;
-#if !SPAN_RUNTIME_SUPPORT
+#if SPAN_RUNTIME_SUPPORT
+using Microsoft.Toolkit.HighPerformance.Memory.Internals;
+#else
 using RuntimeHelpers = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers;
 #endif
 
@@ -64,6 +66,32 @@ internal RefEnumerable(ref T reference, int length, int step)
             Span = MemoryMarshal.CreateSpan(ref reference, length);
             Step = step;
         }
+
+        /// <summary>
+        /// Creates a new instance of the <see cref="RefEnumerable{T}"/> struct with the specified parameters.
+        /// </summary>
+        /// <param name="value">The reference to the first <typeparamref name="T"/> item to map.</param>
+        /// <param name="length">The number of items in the sequence.</param>
+        /// <param name="step">The distance between items in the sequence to enumerate.</param>
+        /// <returns>A <see cref="RefEnumerable{T}"/> instance with the specified parameters.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown when one of the parameters are negative.</exception>
+        [Pure]
+        public static RefEnumerable<T> DangerousCreate(ref T value, int length, int step)
+        {
+            if (length < 0)
+            {
+                ThrowArgumentOutOfRangeExceptionForLength();
+            }
+
+            if (step < 0)
+            {
+                ThrowArgumentOutOfRangeExceptionForStep();
+            }
+
+            OverflowHelper.EnsureIsInNativeIntRange(length, 1, step);
+
+            return new RefEnumerable<T>(ref value, length, step);
+        }
 #else
         /// <summary>
         /// Initializes a new instance of the <see cref="RefEnumerable{T}"/> struct.
@@ -453,6 +481,22 @@ public bool MoveNext()
             }
         }
 
+        /// <summary>
+        /// Throws an <see cref="ArgumentOutOfRangeException"/> when the "length" parameter is invalid.
+        /// </summary>
+        private static void ThrowArgumentOutOfRangeExceptionForLength()
+        {
+            throw new ArgumentOutOfRangeException("length");
+        }
+
+        /// <summary>
+        /// Throws an <see cref="ArgumentOutOfRangeException"/> when the "step" parameter is invalid.
+        /// </summary>
+        private static void ThrowArgumentOutOfRangeExceptionForStep()
+        {
+            throw new ArgumentOutOfRangeException("step");
+        }
+
         /// <summary>
         /// Throws an <see cref="ArgumentException"/> when the target span is too short.
         /// </summary>
diff --git a/Microsoft.Toolkit.HighPerformance/Extensions/ArrayExtensions.1D.cs b/Microsoft.Toolkit.HighPerformance/Extensions/ArrayExtensions.1D.cs
index 6ca8302ed52..75b292d4208 100644
--- a/Microsoft.Toolkit.HighPerformance/Extensions/ArrayExtensions.1D.cs
+++ b/Microsoft.Toolkit.HighPerformance/Extensions/ArrayExtensions.1D.cs
@@ -146,7 +146,7 @@ public static int Count<T>(this T[] array, T value)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static SpanEnumerable<T> Enumerate<T>(this T[] array)
         {
-            return new SpanEnumerable<T>(array);
+            return new(array);
         }
 
         /// <summary>
@@ -172,7 +172,7 @@ public static SpanEnumerable<T> Enumerate<T>(this T[] array)
         public static SpanTokenizer<T> Tokenize<T>(this T[] array, T separator)
             where T : IEquatable<T>
         {
-            return new SpanTokenizer<T>(array, separator);
+            return new(array, separator);
         }
 
         /// <summary>
diff --git a/Microsoft.Toolkit.HighPerformance/Extensions/ArrayExtensions.2D.cs b/Microsoft.Toolkit.HighPerformance/Extensions/ArrayExtensions.2D.cs
index 89781377df8..6b571a68ef1 100644
--- a/Microsoft.Toolkit.HighPerformance/Extensions/ArrayExtensions.2D.cs
+++ b/Microsoft.Toolkit.HighPerformance/Extensions/ArrayExtensions.2D.cs
@@ -207,7 +207,7 @@ public static RefEnumerable<T> GetColumn<T>(this T[,] array, int column)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Span2D<T> AsSpan2D<T>(this T[,]? array)
         {
-            return new Span2D<T>(array);
+            return new(array);
         }
 
         /// <summary>
@@ -231,7 +231,7 @@ public static Span2D<T> AsSpan2D<T>(this T[,]? array)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Span2D<T> AsSpan2D<T>(this T[,]? array, int row, int column, int height, int width)
         {
-            return new Span2D<T>(array, row, column, height, width);
+            return new(array, row, column, height, width);
         }
 
         /// <summary>
@@ -244,7 +244,7 @@ public static Span2D<T> AsSpan2D<T>(this T[,]? array, int row, int column, int h
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Memory2D<T> AsMemory2D<T>(this T[,]? array)
         {
-            return new Memory2D<T>(array);
+            return new(array);
         }
 
         /// <summary>
@@ -268,7 +268,7 @@ public static Memory2D<T> AsMemory2D<T>(this T[,]? array)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Memory2D<T> AsMemory2D<T>(this T[,]? array, int row, int column, int height, int width)
         {
-            return new Memory2D<T>(array, row, column, height, width);
+            return new(array, row, column, height, width);
         }
 
 #if SPAN_RUNTIME_SUPPORT
diff --git a/Microsoft.Toolkit.HighPerformance/Extensions/ArrayExtensions.3D.cs b/Microsoft.Toolkit.HighPerformance/Extensions/ArrayExtensions.3D.cs
index 77ad9983a6e..ba4f0bd498d 100644
--- a/Microsoft.Toolkit.HighPerformance/Extensions/ArrayExtensions.3D.cs
+++ b/Microsoft.Toolkit.HighPerformance/Extensions/ArrayExtensions.3D.cs
@@ -234,7 +234,7 @@ public static Memory<T> AsMemory<T>(this T[,,] array, int depth)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Span2D<T> AsSpan2D<T>(this T[,,] array, int depth)
         {
-            return new Span2D<T>(array, depth);
+            return new(array, depth);
         }
 
         /// <summary>
@@ -252,7 +252,7 @@ public static Span2D<T> AsSpan2D<T>(this T[,,] array, int depth)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Memory2D<T> AsMemory2D<T>(this T[,,] array, int depth)
         {
-            return new Memory2D<T>(array, depth);
+            return new(array, depth);
         }
 
         /// <summary>
diff --git a/Microsoft.Toolkit.HighPerformance/Extensions/MemoryExtensions.cs b/Microsoft.Toolkit.HighPerformance/Extensions/MemoryExtensions.cs
index 411fb5f390b..1feeb36c966 100644
--- a/Microsoft.Toolkit.HighPerformance/Extensions/MemoryExtensions.cs
+++ b/Microsoft.Toolkit.HighPerformance/Extensions/MemoryExtensions.cs
@@ -35,7 +35,7 @@ public static class MemoryExtensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Memory2D<T> AsMemory2D<T>(this Memory<T> memory, int height, int width)
         {
-            return new Memory2D<T>(memory, height, width);
+            return new(memory, height, width);
         }
 
         /// <summary>
@@ -58,7 +58,7 @@ public static Memory2D<T> AsMemory2D<T>(this Memory<T> memory, int height, int w
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Memory2D<T> AsMemory2D<T>(this Memory<T> memory, int offset, int height, int width, int pitch)
         {
-            return new Memory2D<T>(memory, offset, height, width, pitch);
+            return new(memory, offset, height, width, pitch);
         }
 #endif
 
diff --git a/Microsoft.Toolkit.HighPerformance/Extensions/ReadOnlyMemoryExtensions.cs b/Microsoft.Toolkit.HighPerformance/Extensions/ReadOnlyMemoryExtensions.cs
index 5e4a07df9ea..ad046a1c68f 100644
--- a/Microsoft.Toolkit.HighPerformance/Extensions/ReadOnlyMemoryExtensions.cs
+++ b/Microsoft.Toolkit.HighPerformance/Extensions/ReadOnlyMemoryExtensions.cs
@@ -38,7 +38,7 @@ public static class ReadOnlyMemoryExtensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static ReadOnlyMemory2D<T> AsMemory2D<T>(this ReadOnlyMemory<T> memory, int height, int width)
         {
-            return new ReadOnlyMemory2D<T>(memory, height, width);
+            return new(memory, height, width);
         }
 
         /// <summary>
@@ -61,7 +61,7 @@ public static ReadOnlyMemory2D<T> AsMemory2D<T>(this ReadOnlyMemory<T> memory, i
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static ReadOnlyMemory2D<T> AsMemory2D<T>(this ReadOnlyMemory<T> memory, int offset, int height, int width, int pitch)
         {
-            return new ReadOnlyMemory2D<T>(memory, offset, height, width, pitch);
+            return new(memory, offset, height, width, pitch);
         }
 #endif
 
diff --git a/Microsoft.Toolkit.HighPerformance/Extensions/ReadOnlySpanExtensions.cs b/Microsoft.Toolkit.HighPerformance/Extensions/ReadOnlySpanExtensions.cs
index 2f81a359ff4..cb793eada03 100644
--- a/Microsoft.Toolkit.HighPerformance/Extensions/ReadOnlySpanExtensions.cs
+++ b/Microsoft.Toolkit.HighPerformance/Extensions/ReadOnlySpanExtensions.cs
@@ -183,7 +183,7 @@ public static class ReadOnlySpanExtensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static ReadOnlySpan2D<T> AsSpan2D<T>(this ReadOnlySpan<T> span, int height, int width)
         {
-            return new ReadOnlySpan2D<T>(span, height, width);
+            return new(span, height, width);
         }
 
         /// <summary>
@@ -206,7 +206,7 @@ public static ReadOnlySpan2D<T> AsSpan2D<T>(this ReadOnlySpan<T> span, int heigh
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static ReadOnlySpan2D<T> AsSpan2D<T>(this ReadOnlySpan<T> span, int offset, int height, int width, int pitch)
         {
-            return new ReadOnlySpan2D<T>(span, offset, height, width, pitch);
+            return new(span, offset, height, width, pitch);
         }
 #endif
 
@@ -313,7 +313,7 @@ public static ReadOnlySpan<byte> AsBytes<T>(this ReadOnlySpan<T> span)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static ReadOnlySpanEnumerable<T> Enumerate<T>(this ReadOnlySpan<T> span)
         {
-            return new ReadOnlySpanEnumerable<T>(span);
+            return new(span);
         }
 
         /// <summary>
@@ -339,7 +339,7 @@ public static ReadOnlySpanEnumerable<T> Enumerate<T>(this ReadOnlySpan<T> span)
         public static ReadOnlySpanTokenizer<T> Tokenize<T>(this ReadOnlySpan<T> span, T separator)
             where T : IEquatable<T>
         {
-            return new ReadOnlySpanTokenizer<T>(span, separator);
+            return new(span, separator);
         }
 
         /// <summary>
diff --git a/Microsoft.Toolkit.HighPerformance/Extensions/SpanExtensions.cs b/Microsoft.Toolkit.HighPerformance/Extensions/SpanExtensions.cs
index 8ad885e0168..d82bad3d4db 100644
--- a/Microsoft.Toolkit.HighPerformance/Extensions/SpanExtensions.cs
+++ b/Microsoft.Toolkit.HighPerformance/Extensions/SpanExtensions.cs
@@ -85,7 +85,7 @@ public static class SpanExtensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Span2D<T> AsSpan2D<T>(this Span<T> span, int height, int width)
         {
-            return new Span2D<T>(span, height, width);
+            return new(span, height, width);
         }
 
         /// <summary>
@@ -108,7 +108,7 @@ public static Span2D<T> AsSpan2D<T>(this Span<T> span, int height, int width)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Span2D<T> AsSpan2D<T>(this Span<T> span, int offset, int height, int width, int pitch)
         {
-            return new Span2D<T>(span, offset, height, width, pitch);
+            return new(span, offset, height, width, pitch);
         }
 #endif
 
@@ -214,7 +214,7 @@ public static int Count<T>(this Span<T> span, T value)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static SpanEnumerable<T> Enumerate<T>(this Span<T> span)
         {
-            return new SpanEnumerable<T>(span);
+            return new(span);
         }
 
         /// <summary>
@@ -240,7 +240,7 @@ public static SpanEnumerable<T> Enumerate<T>(this Span<T> span)
         public static SpanTokenizer<T> Tokenize<T>(this Span<T> span, T separator)
             where T : IEquatable<T>
         {
-            return new SpanTokenizer<T>(span, separator);
+            return new(span, separator);
         }
 
         /// <summary>
diff --git a/Microsoft.Toolkit.HighPerformance/Extensions/SpinLockExtensions.cs b/Microsoft.Toolkit.HighPerformance/Extensions/SpinLockExtensions.cs
index f1e826bd2f7..d17eab8fae4 100644
--- a/Microsoft.Toolkit.HighPerformance/Extensions/SpinLockExtensions.cs
+++ b/Microsoft.Toolkit.HighPerformance/Extensions/SpinLockExtensions.cs
@@ -32,7 +32,7 @@ public static class SpinLockExtensions
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe UnsafeLock Enter(SpinLock* spinLock)
         {
-            return new UnsafeLock(spinLock);
+            return new(spinLock);
         }
 
         /// <summary>
@@ -97,7 +97,7 @@ public void Dispose()
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Lock Enter(ref this SpinLock spinLock)
         {
-            return new Lock(ref spinLock);
+            return new(ref spinLock);
         }
 #else
         /// <summary>
@@ -123,7 +123,7 @@ public static Lock Enter(ref this SpinLock spinLock)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Lock Enter(object owner, ref SpinLock spinLock)
         {
-            return new Lock(owner, ref spinLock);
+            return new(owner, ref spinLock);
         }
 #endif
 
diff --git a/Microsoft.Toolkit.HighPerformance/Extensions/StringExtensions.cs b/Microsoft.Toolkit.HighPerformance/Extensions/StringExtensions.cs
index 9ea1def2243..9690ad1729e 100644
--- a/Microsoft.Toolkit.HighPerformance/Extensions/StringExtensions.cs
+++ b/Microsoft.Toolkit.HighPerformance/Extensions/StringExtensions.cs
@@ -121,7 +121,7 @@ public static int Count(this string text, char c)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static ReadOnlySpanEnumerable<char> Enumerate(this string text)
         {
-            return new ReadOnlySpanEnumerable<char>(text.AsSpan());
+            return new(text.AsSpan());
         }
 
         /// <summary>
@@ -145,7 +145,7 @@ public static ReadOnlySpanEnumerable<char> Enumerate(this string text)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static ReadOnlySpanTokenizer<char> Tokenize(this string text, char separator)
         {
-            return new ReadOnlySpanTokenizer<char>(text.AsSpan(), separator);
+            return new(text.AsSpan(), separator);
         }
 
         /// <summary>
diff --git a/Microsoft.Toolkit.HighPerformance/Memory/Memory2D{T}.cs b/Microsoft.Toolkit.HighPerformance/Memory/Memory2D{T}.cs
index bdd425a99e9..6f6a7262222 100644
--- a/Microsoft.Toolkit.HighPerformance/Memory/Memory2D{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/Memory/Memory2D{T}.cs
@@ -900,6 +900,6 @@ public override string ToString()
         /// <summary>
         /// Defines an implicit conversion of an array to a <see cref="Memory2D{T}"/>
         /// </summary>
-        public static implicit operator Memory2D<T>(T[,]? array) => new Memory2D<T>(array);
+        public static implicit operator Memory2D<T>(T[,]? array) => new(array);
     }
 }
diff --git a/Microsoft.Toolkit.HighPerformance/Memory/ReadOnlyMemory2D{T}.cs b/Microsoft.Toolkit.HighPerformance/Memory/ReadOnlyMemory2D{T}.cs
index 9f3ea970b86..80e8839cb85 100644
--- a/Microsoft.Toolkit.HighPerformance/Memory/ReadOnlyMemory2D{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/Memory/ReadOnlyMemory2D{T}.cs
@@ -625,14 +625,14 @@ public ReadOnlySpan2D<T> Span
                         ref T r0 = ref memoryManager.GetSpan().DangerousGetReference();
                         ref T r1 = ref Unsafe.Add(ref r0, this.offset);
 
-                        return new ReadOnlySpan2D<T>(r1, this.height, this.width, this.pitch);
+                        return new ReadOnlySpan2D<T>(in r1, this.height, this.width, this.pitch);
                     }
                     else
                     {
                         // This handles both arrays and strings
                         ref T r0 = ref this.instance.DangerousGetObjectDataReferenceAt<T>(this.offset);
 
-                        return new ReadOnlySpan2D<T>(r0, this.height, this.width, this.pitch);
+                        return new ReadOnlySpan2D<T>(in r0, this.height, this.width, this.pitch);
                     }
 #else
                     return new ReadOnlySpan2D<T>(this.instance, this.offset, this.height, this.width, this.pitch);
@@ -913,7 +913,7 @@ public override string ToString()
         /// <summary>
         /// Defines an implicit conversion of an array to a <see cref="ReadOnlyMemory2D{T}"/>
         /// </summary>
-        public static implicit operator ReadOnlyMemory2D<T>(T[,]? array) => new ReadOnlyMemory2D<T>(array);
+        public static implicit operator ReadOnlyMemory2D<T>(T[,]? array) => new(array);
 
         /// <summary>
         /// Defines an implicit conversion of a <see cref="Memory2D{T}"/> to a <see cref="ReadOnlyMemory2D{T}"/>
diff --git a/Microsoft.Toolkit.HighPerformance/Memory/ReadOnlySpan2D{T}.Enumerator.cs b/Microsoft.Toolkit.HighPerformance/Memory/ReadOnlySpan2D{T}.Enumerator.cs
index 24f6e504462..4f1ddedc4de 100644
--- a/Microsoft.Toolkit.HighPerformance/Memory/ReadOnlySpan2D{T}.Enumerator.cs
+++ b/Microsoft.Toolkit.HighPerformance/Memory/ReadOnlySpan2D{T}.Enumerator.cs
@@ -38,7 +38,7 @@ public ReadOnlyRefEnumerable<T> GetRow(int row)
             ref T r1 = ref Unsafe.Add(ref r0, startIndex);
 
 #if SPAN_RUNTIME_SUPPORT
-            return new ReadOnlyRefEnumerable<T>(r1, Width, 1);
+            return new ReadOnlyRefEnumerable<T>(in r1, Width, 1);
 #else
             IntPtr offset = RuntimeHelpers.GetObjectDataOrReferenceByteOffset(this.instance, ref r1);
 
@@ -65,7 +65,7 @@ public ReadOnlyRefEnumerable<T> GetColumn(int column)
             ref T r1 = ref Unsafe.Add(ref r0, (nint)(uint)column);
 
 #if SPAN_RUNTIME_SUPPORT
-            return new ReadOnlyRefEnumerable<T>(r1, Height, this.stride);
+            return new ReadOnlyRefEnumerable<T>(in r1, Height, this.stride);
 #else
             IntPtr offset = RuntimeHelpers.GetObjectDataOrReferenceByteOffset(this.instance, ref r1);
 
@@ -81,7 +81,7 @@ public ReadOnlyRefEnumerable<T> GetColumn(int column)
         /// </returns>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public Enumerator GetEnumerator() => new Enumerator(this);
+        public Enumerator GetEnumerator() => new(this);
 
         /// <summary>
         /// Provides an enumerator for the elements of a <see cref="ReadOnlySpan2D{T}"/> instance.
diff --git a/Microsoft.Toolkit.HighPerformance/Memory/ReadOnlySpan2D{T}.cs b/Microsoft.Toolkit.HighPerformance/Memory/ReadOnlySpan2D{T}.cs
index 46564207512..17c9f5df51b 100644
--- a/Microsoft.Toolkit.HighPerformance/Memory/ReadOnlySpan2D{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/Memory/ReadOnlySpan2D{T}.cs
@@ -478,7 +478,7 @@ public static ReadOnlySpan2D<T> DangerousCreate(in T value, int height, int widt
 
             OverflowHelper.EnsureIsInNativeIntRange(height, width, pitch);
 
-            return new ReadOnlySpan2D<T>(value, height, width, pitch);
+            return new ReadOnlySpan2D<T>(in value, height, width, pitch);
         }
 #endif
 
@@ -837,7 +837,7 @@ public ReadOnlySpan2D<T> Slice(int row, int column, int width, int height)
 #if SPAN_RUNTIME_SUPPORT
             ref T r0 = ref this.span.DangerousGetReferenceAt(shift);
 
-            return new ReadOnlySpan2D<T>(r0, height, width, pitch);
+            return new ReadOnlySpan2D<T>(in r0, height, width, pitch);
 #else
             IntPtr offset = this.offset + (shift * (nint)(uint)Unsafe.SizeOf<T>());
 
@@ -1012,7 +1012,7 @@ public override string ToString()
         /// Implicily converts a given 2D array into a <see cref="ReadOnlySpan2D{T}"/> instance.
         /// </summary>
         /// <param name="array">The input 2D array to convert.</param>
-        public static implicit operator ReadOnlySpan2D<T>(T[,]? array) => new ReadOnlySpan2D<T>(array);
+        public static implicit operator ReadOnlySpan2D<T>(T[,]? array) => new(array);
 
         /// <summary>
         /// Implicily converts a given <see cref="Span2D{T}"/> into a <see cref="ReadOnlySpan2D{T}"/> instance.
@@ -1021,7 +1021,7 @@ public override string ToString()
         public static implicit operator ReadOnlySpan2D<T>(Span2D<T> span)
         {
 #if SPAN_RUNTIME_SUPPORT
-            return new ReadOnlySpan2D<T>(span.DangerousGetReference(), span.Height, span.Width, span.Stride - span.Width);
+            return new ReadOnlySpan2D<T>(in span.DangerousGetReference(), span.Height, span.Width, span.Stride - span.Width);
 #else
             return new ReadOnlySpan2D<T>(span.Instance!, span.Offset, span.Height, span.Width, span.Stride - span.Width);
 #endif
diff --git a/Microsoft.Toolkit.HighPerformance/Memory/Span2D{T}.Enumerator.cs b/Microsoft.Toolkit.HighPerformance/Memory/Span2D{T}.Enumerator.cs
index 99e796d7a79..add6e255d24 100644
--- a/Microsoft.Toolkit.HighPerformance/Memory/Span2D{T}.Enumerator.cs
+++ b/Microsoft.Toolkit.HighPerformance/Memory/Span2D{T}.Enumerator.cs
@@ -81,7 +81,7 @@ public RefEnumerable<T> GetColumn(int column)
         /// </returns>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public Enumerator GetEnumerator() => new Enumerator(this);
+        public Enumerator GetEnumerator() => new(this);
 
         /// <summary>
         /// Provides an enumerator for the elements of a <see cref="Span2D{T}"/> instance.
diff --git a/Microsoft.Toolkit.HighPerformance/Memory/Span2D{T}.cs b/Microsoft.Toolkit.HighPerformance/Memory/Span2D{T}.cs
index 7f9009ad947..ecdeeccfb58 100644
--- a/Microsoft.Toolkit.HighPerformance/Memory/Span2D{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/Memory/Span2D{T}.cs
@@ -1168,6 +1168,6 @@ public override string ToString()
         /// Implicily converts a given 2D array into a <see cref="Span2D{T}"/> instance.
         /// </summary>
         /// <param name="array">The input 2D array to convert.</param>
-        public static implicit operator Span2D<T>(T[,]? array) => new Span2D<T>(array);
+        public static implicit operator Span2D<T>(T[,]? array) => new(array);
     }
 }
diff --git a/Microsoft.Toolkit.HighPerformance/NullableReadOnlyRef{T}.cs b/Microsoft.Toolkit.HighPerformance/NullableReadOnlyRef{T}.cs
index 9cf22c0a1aa..9d364b4bc07 100644
--- a/Microsoft.Toolkit.HighPerformance/NullableReadOnlyRef{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/NullableReadOnlyRef{T}.cs
@@ -92,7 +92,7 @@ public unsafe bool HasValue
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator NullableReadOnlyRef<T>(Ref<T> reference)
         {
-            return new NullableReadOnlyRef<T>(reference.Span);
+            return new(reference.Span);
         }
 
         /// <summary>
@@ -102,7 +102,7 @@ public unsafe bool HasValue
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator NullableReadOnlyRef<T>(ReadOnlyRef<T> reference)
         {
-            return new NullableReadOnlyRef<T>(reference.Span);
+            return new(reference.Span);
         }
 
         /// <summary>
@@ -112,7 +112,7 @@ public unsafe bool HasValue
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator NullableReadOnlyRef<T>(NullableRef<T> reference)
         {
-            return new NullableReadOnlyRef<T>(reference.Span);
+            return new(reference.Span);
         }
 
         /// <summary>
diff --git a/Microsoft.Toolkit.HighPerformance/NullableRef{T}.cs b/Microsoft.Toolkit.HighPerformance/NullableRef{T}.cs
index c7c61b96745..2f694537aa9 100644
--- a/Microsoft.Toolkit.HighPerformance/NullableRef{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/NullableRef{T}.cs
@@ -96,7 +96,7 @@ public unsafe bool HasValue
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator NullableRef<T>(Ref<T> reference)
         {
-            return new NullableRef<T>(reference.Span);
+            return new(reference.Span);
         }
 
         /// <summary>
diff --git a/Microsoft.Toolkit.HighPerformance/ReadOnlyRef{T}.cs b/Microsoft.Toolkit.HighPerformance/ReadOnlyRef{T}.cs
index 1945e1dffde..37401184821 100644
--- a/Microsoft.Toolkit.HighPerformance/ReadOnlyRef{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/ReadOnlyRef{T}.cs
@@ -42,7 +42,7 @@ public ReadOnlyRef(in T value)
         /// <param name="pointer">The pointer to the target value.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public unsafe ReadOnlyRef(void* pointer)
-            : this(Unsafe.AsRef<T>(pointer))
+            : this(in Unsafe.AsRef<T>(pointer))
         {
         }
 
@@ -62,7 +62,7 @@ public unsafe ReadOnlyRef(void* pointer)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator ReadOnlyRef<T>(Ref<T> reference)
         {
-            return new ReadOnlyRef<T>(reference.Value);
+            return new(in reference.Value);
         }
 #else
         /// <summary>
@@ -117,7 +117,7 @@ public ReadOnlyRef(object owner, in T value)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static implicit operator ReadOnlyRef<T>(Ref<T> reference)
         {
-            return new ReadOnlyRef<T>(reference.Owner, reference.Offset);
+            return new(reference.Owner, reference.Offset);
         }
 #endif
 
diff --git a/Microsoft.Toolkit.HighPerformance/Streams/Sources/ArrayOwner.cs b/Microsoft.Toolkit.HighPerformance/Streams/Sources/ArrayOwner.cs
index 8749ab7682e..5018354e74f 100644
--- a/Microsoft.Toolkit.HighPerformance/Streams/Sources/ArrayOwner.cs
+++ b/Microsoft.Toolkit.HighPerformance/Streams/Sources/ArrayOwner.cs
@@ -50,7 +50,7 @@ public ArrayOwner(byte[] array, int offset, int length)
         public static ArrayOwner Empty
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => new ArrayOwner(Array.Empty<byte>(), 0, 0);
+            get => new(Array.Empty<byte>(), 0, 0);
         }
 
         /// <inheritdoc/>
diff --git a/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_ReadOnlyRefEnumerable{T}.cs b/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_ReadOnlyRefEnumerable{T}.cs
new file mode 100644
index 00000000000..f1a8871fdde
--- /dev/null
+++ b/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_ReadOnlyRefEnumerable{T}.cs
@@ -0,0 +1,53 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if !WINDOWS_UWP
+
+using System;
+using System.Runtime.CompilerServices;
+using Microsoft.Toolkit.HighPerformance.Enumerables;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace UnitTests.HighPerformance.Enumerables
+{
+    [TestClass]
+    public class Test_ReadOnlyRefEnumerable
+    {
+        [TestCategory("ReadOnlyRefEnumerable")]
+        [TestMethod]
+        [DataRow(1, 1, new[] { 1 })]
+        [DataRow(4, 1, new[] { 1, 2, 3, 4 })]
+        [DataRow(4, 4, new[] { 1, 5, 9, 13 })]
+        [DataRow(4, 5, new[] { 1, 6, 11, 16 })]
+        public void Test_ReadOnlyRefEnumerable_DangerousCreate_Ok(int length, int step, int[] values)
+        {
+            Span<int> data = new[]
+            {
+                1, 2, 3, 4,
+                5, 6, 7, 8,
+                9, 10, 11, 12,
+                13, 14, 15, 16
+            };
+
+            ReadOnlyRefEnumerable<int> enumerable = ReadOnlyRefEnumerable<int>.DangerousCreate(in data[0], length, step);
+
+            int[] result = enumerable.ToArray();
+
+            CollectionAssert.AreEqual(result, values);
+        }
+
+        [TestCategory("ReadOnlyRefEnumerable")]
+        [TestMethod]
+        [DataRow(-44, 10)]
+        [DataRow(10, -14)]
+        [DataRow(-32, -1)]
+        [ExpectedException(typeof(ArgumentOutOfRangeException))]
+        public void Test_ReadOnlyRefEnumerable_DangerousCreate_BelowZero(int length, int step)
+        {
+            _ = ReadOnlyRefEnumerable<int>.DangerousCreate(in Unsafe.NullRef<int>(), length, step);
+        }
+    }
+}
+
+#endif
diff --git a/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_RefEnumerable{T}.cs b/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_RefEnumerable{T}.cs
new file mode 100644
index 00000000000..f82bff8bb28
--- /dev/null
+++ b/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_RefEnumerable{T}.cs
@@ -0,0 +1,53 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#if !WINDOWS_UWP
+
+using System;
+using System.Runtime.CompilerServices;
+using Microsoft.Toolkit.HighPerformance.Enumerables;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace UnitTests.HighPerformance.Enumerables
+{
+    [TestClass]
+    public class Test_RefEnumerable
+    {
+        [TestCategory("RefEnumerable")]
+        [TestMethod]
+        [DataRow(1, 1, new[] { 1 })]
+        [DataRow(4, 1, new[] { 1, 2, 3, 4 })]
+        [DataRow(4, 4, new[] { 1, 5, 9, 13 })]
+        [DataRow(4, 5, new[] { 1, 6, 11, 16 })]
+        public void Test_RefEnumerable_DangerousCreate_Ok(int length, int step, int[] values)
+        {
+            Span<int> data = new[]
+            {
+                1, 2, 3, 4,
+                5, 6, 7, 8,
+                9, 10, 11, 12,
+                13, 14, 15, 16
+            };
+
+            RefEnumerable<int> enumerable = RefEnumerable<int>.DangerousCreate(ref data[0], length, step);
+
+            int[] result = enumerable.ToArray();
+
+            CollectionAssert.AreEqual(result, values);
+        }
+
+        [TestCategory("RefEnumerable")]
+        [TestMethod]
+        [DataRow(-44, 10)]
+        [DataRow(10, -14)]
+        [DataRow(-32, -1)]
+        [ExpectedException(typeof(ArgumentOutOfRangeException))]
+        public void Test_RefEnumerable_DangerousCreate_BelowZero(int length, int step)
+        {
+            _ = RefEnumerable<int>.DangerousCreate(ref Unsafe.NullRef<int>(), length, step);
+        }
+    }
+}
+
+#endif
diff --git a/UnitTests/UnitTests.HighPerformance.Shared/UnitTests.HighPerformance.Shared.projitems b/UnitTests/UnitTests.HighPerformance.Shared/UnitTests.HighPerformance.Shared.projitems
index a114963de54..7efff4b2ef4 100644
--- a/UnitTests/UnitTests.HighPerformance.Shared/UnitTests.HighPerformance.Shared.projitems
+++ b/UnitTests/UnitTests.HighPerformance.Shared/UnitTests.HighPerformance.Shared.projitems
@@ -16,6 +16,8 @@
     <Compile Include="$(MSBuildThisFileDirectory)Buffers\Test_StringPool.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Buffers\Test_SpanOwner{T}.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Buffers\TrackingArrayPool{T}.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Enumerables\Test_ReadOnlyRefEnumerable{T}.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Enumerables\Test_RefEnumerable{T}.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\Test_ArrayExtensions.3D.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\Test_ArrayExtensions.2D.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Extensions\Test_ArrayExtensions.1D.cs" />