Compare 2D arrays without boxing their cells

CSharpExt.UnitTests/IArray2dExtTests.cs

@@ -0,0 +1,54 @@
+using Noggog;
+using Shouldly;
+
+namespace CSharpExt.UnitTests;
+
+public class IArray2dExtTests
+{
+    [Fact]
+    public void SequenceEqualNullableSameValues()
+    {
+        IReadOnlyArray2d<int> lhs = Numbered(2, 3);
+        IReadOnlyArray2d<int> rhs = Numbered(2, 3);
+        lhs.SequenceEqualNullable(rhs).ShouldBeTrue();
+    }
+
+    [Fact]
+    public void SequenceEqualNullableDifferentValue()
+    {
+        IReadOnlyArray2d<int> lhs = Numbered(2, 3);
+        var rhs = Numbered(2, 3);
+        rhs[1, 2] = -1;
+        lhs.SequenceEqualNullable(rhs).ShouldBeFalse();
+    }
+
+    [Fact]
+    public void SequenceEqualNullableDifferentSize()
+    {
+        IReadOnlyArray2d<int> lhs = new Array2d<int>(2, 3, 0);
+        IReadOnlyArray2d<int> rhs = new Array2d<int>(3, 2, 0);
+        lhs.SequenceEqualNullable(rhs).ShouldBeFalse();
+    }
+
+    [Fact]
+    public void SequenceEqualNullableNull()
+    {
+        IReadOnlyArray2d<int>? missing = null;
+        missing.SequenceEqualNullable(null).ShouldBeTrue();
+        missing.SequenceEqualNullable(Numbered(2, 3)).ShouldBeFalse();
+        ((IReadOnlyArray2d<int>)Numbered(2, 3)).SequenceEqualNullable(null).ShouldBeFalse();
+    }
+
+    private static Array2d<int> Numbered(int width, int height)
+    {
+        var array = new Array2d<int>(width, height, 0);
+        for (var y = 0; y < height; y++)
+        {
+            for (var x = 0; x < width; x++)
+            {
+                array[x, y] = y * width + x;
+            }
+        }
+        return array;
+    }
+}

Noggog.CSharpExt/Containers/Interfaces/IArray2d.cs

@@ -21,6 +21,21 @@ public interface IArray2d<T> : IReadOnlyArray2d<T>, IEnumerable<KeyValuePair<P2I
 
 public static class IArray2dExt
 {
+    public static bool SequenceEqualNullable<T>(this IReadOnlyArray2d<T>? lhs, IReadOnlyArray2d<T>? rhs)
+    {
+        if (ReferenceEquals(lhs, rhs)) return true;
+        if (lhs is null || rhs is null || lhs.Width != rhs.Width || lhs.Height != rhs.Height) return false;
+        var comparer = EqualityComparer<T>.Default;
+        for (var y = 0; y < lhs.Height; y++)
+        {
+            for (var x = 0; x < lhs.Width; x++)
+            {
+                if (!comparer.Equals(lhs[x, y], rhs[x, y])) return false;
+            }
+        }
+        return true;
+    }
+
     public static Array2d<T> ShallowClone<T>(this IReadOnlyArray2d<T> arr)
     {
         if (arr is Array2d<T> direct)
@@ -42,4 +57,4 @@ public static void SetTo<T>(this IArray2d<T> arr, IEnumerable<KeyValuePair<P2Int
         arr.SetAllTo(fallback);
         arr.Set(vals);
     }
-}
+}