Implement IReadOnlyList instead of IEnumerable

osu.Framework.Tests/Visual/Layout/TestSceneTableContainer.cs

···
         public void TestOnlyContent()
         {
             AddStep("set content", () => table.Content = createContent(2, 2));
-            AddAssert("headers not displayed", () => getGrid().Content.Count() == 2);
+            AddAssert("headers not displayed", () => getGrid().Content.Count == 2);
         }
 
         [Test]
···
                 };
             });
 
-            AddAssert("4 rows", () => getGrid().Content.Count() == 4);
+            AddAssert("4 rows", () => getGrid().Content.Count == 4);
             AddStep("disable headers", () => table.ShowHeaders = false);
-            AddAssert("3 rows", () => getGrid().Content.Count() == 3);
+            AddAssert("3 rows", () => getGrid().Content.Count == 3);
         }
 
         [Test]
···
                 };
             });
 
-            AddAssert("3 columns", () => getGrid().Content.Max(r => r.Count()) == 3);
+            AddAssert("3 columns", () => getGrid().Content.Max(r => r.Count) == 3);
             AddStep("disable headers", () => table.ShowHeaders = false);
-            AddAssert("2 columns", () => getGrid().Content.Max(r => r.Count()) == 2);
+            AddAssert("2 columns", () => getGrid().Content.Max(r => r.Count) == 2);
         }
 
         [Test]
···
                 };
             });
 
-            AddAssert("3 columns", () => getGrid().Content.Max(r => r.Count()) == 3);
+            AddAssert("3 columns", () => getGrid().Content.Max(r => r.Count) == 3);
             AddStep("disable headers", () => table.ShowHeaders = false);
-            AddAssert("2 columns", () => getGrid().Content.Max(r => r.Count()) == 3);
+            AddAssert("2 columns", () => getGrid().Content.Max(r => r.Count) == 3);
         }
 
         [Test]
···
 
             bool testColumn(int index, Anchor anchor)
             {
-                for (int r = 0; r < getGrid().Content.Count(); r++)
+                for (int r = 0; r < getGrid().Content.Count; r++)
                 {
                     if (getGrid().Content[r][index].Anchor != anchor)
                         return false;
···
                 new TableColumn("Header 3"),
             });
 
-            AddAssert("3 columns", () => getGrid().Content.Max(r => r.Count()) == 3);
+            AddAssert("3 columns", () => getGrid().Content.Max(r => r.Count) == 3);
 
             AddStep("decrease columns", () => table.Columns = new[]
             {
                 new TableColumn("Header 1"),
             });
 
-            AddAssert("2 columns", () => getGrid().Content.Max(r => r.Count()) == 2);
+            AddAssert("2 columns", () => getGrid().Content.Max(r => r.Count) == 2);
         }
 
         [Test]
···
 
             bool testRows(float expectedHeight)
             {
-                for (int row = 0; row < getGrid().Content.Count(); row++)
+                for (int row = 0; row < getGrid().Content.Count; row++)
                 {
                     if (!Precision.AlmostEquals(expectedHeight, getGrid().Content[row][0].Parent.DrawHeight))
                         return false;

osu.Framework/Graphics/Containers/GridContainer.cs

···
             if (cellContent.IsValid)
                 return;
 
-            int requiredRows = Content?.Count() ?? 0;
-            int requiredColumns = requiredRows == 0 ? 0 : Content?.Max(c => c?.WrappedArray.Length ?? 0) ?? 0;
+            int requiredRows = Content?.Count ?? 0;
+            int requiredColumns = requiredRows == 0 ? 0 : Content?.Max(c => c?.Count ?? 0) ?? 0;
 
             // Clear cell containers without disposing, as the content might be reused
             foreach (var cell in cells)
···
                         continue;
 
                     // Allow non-square grids
-                    if (c >= Content[r].WrappedArray.Length)
+                    if (c >= Content[r].Count)
                         continue;
 
                     // Allow empty cells

osu.Framework/Graphics/Containers/GridContainerContent.cs

···
     /// <summary>
     /// Implements a jagged array behavior with element change notifications
     /// </summary>
-    public class GridContainerContent : IEnumerable<GridContainerContent.ArrayWrapper<Drawable>>
+    public class GridContainerContent : IReadOnlyList<GridContainerContent.ArrayWrapper<Drawable>>
     {
         public event Action ContentChanged;
 
···
         {
             source = drawables;
 
-            wrappedArray = new ArrayWrapper<ArrayWrapper<Drawable>>
-            {
-                WrappedArray = new ArrayWrapper<Drawable>[drawables?.Length ?? 0]
-            };
+            wrappedArray = new ArrayWrapper<ArrayWrapper<Drawable>>(new ArrayWrapper<Drawable>[drawables?.Length ?? 0]);
 
             wrappedArray.ArrayElementChanged += onArrayElementChanged;
 
···
                 {
                     if (drawables[i] != null)
                     {
-                        this[i] = new ArrayWrapper<Drawable> { WrappedArray = drawables[i] };
+                        this[i] = new ArrayWrapper<Drawable>(drawables[i]);
                         this[i].ArrayElementChanged += onArrayElementChanged;
                     }
                 }
···
         /// Wraps an array and provides a custom indexer with element change notification
         /// </summary>
         /// <typeparam name="T">An array data type</typeparam>
-        public class ArrayWrapper<T> : IEnumerable<T>
+        public class ArrayWrapper<T> : IReadOnlyList<T>
         {
             public event Action ArrayElementChanged;
 
-            public T[] WrappedArray { get; set; }
+            private T[] wrappedArray { get; set; }
+
+            public ArrayWrapper(T[] arrayToWrap)
+            {
+                wrappedArray = arrayToWrap;
+            }
 
             public T this[int index]
             {
-                get => WrappedArray[index];
+                get => wrappedArray[index];
                 set
                 {
-                    if (EqualityComparer<T>.Default.Equals(WrappedArray[index], value))
+                    if (EqualityComparer<T>.Default.Equals(wrappedArray[index], value))
                         return;
 
-                    WrappedArray[index] = value;
+                    wrappedArray[index] = value;
                     ArrayElementChanged?.Invoke();
                 }
             }
 
             public IEnumerator<T> GetEnumerator()
             {
-                return ((IEnumerable<T>)WrappedArray).GetEnumerator();
+                return ((IEnumerable<T>)wrappedArray).GetEnumerator();
             }
 
             IEnumerator IEnumerable.GetEnumerator()
             {
-                return WrappedArray.GetEnumerator();
+                return wrappedArray.GetEnumerator();
             }
+
+            public int Count => wrappedArray.Length;
         }
 
         public IEnumerator<ArrayWrapper<Drawable>> GetEnumerator()
         {
-            return ((IEnumerable<ArrayWrapper<Drawable>>)wrappedArray.WrappedArray).GetEnumerator();
+            return ((IEnumerable<ArrayWrapper<Drawable>>)wrappedArray).GetEnumerator();
         }
 
         IEnumerator IEnumerable.GetEnumerator()
         {
-            return wrappedArray.WrappedArray.GetEnumerator();
+            return wrappedArray.GetEnumerator();
         }
+
+        public int Count => wrappedArray.Count;
     }
 }

osu.Framework/Graphics/Containers/Markdown/MarkdownTable.cs

···
             if (table.Count == 0)
                 return;
 
-            Span<float> columnWidths = stackalloc float[tableContainer.Content[0].WrappedArray.Length];
+            Span<float> columnWidths = stackalloc float[tableContainer.Content[0].Count];
 
             // Compute the maximum width of each column
-            for (int r = 0; r < tableContainer.Content.Count(); r++)
+            for (int r = 0; r < tableContainer.Content.Count; r++)
             {
-                for (int c = 0; c < tableContainer.Content[r].WrappedArray.Length; c++)
+                for (int c = 0; c < tableContainer.Content[r].Count; c++)
                     columnWidths[c] = Math.Max(columnWidths[c], ((MarkdownTableCell)tableContainer.Content[r][c]).ContentWidth);
             }
 
···
             if (table.Count == 0)
                 return;
 
-            var rowDefinitions = new Dimension[tableContainer.Content.Count()];
-            for (int r = 0; r < tableContainer.Content.Count(); r++)
-                rowDefinitions[r] = new Dimension(GridSizeMode.Absolute, tableContainer.Content[r].WrappedArray.Max(c => ((MarkdownTableCell)c).ContentHeight));
+            var rowDefinitions = new Dimension[tableContainer.Content.Count];
+            for (int r = 0; r < tableContainer.Content.Count; r++)
+                rowDefinitions[r] = new Dimension(GridSizeMode.Absolute, tableContainer.Content[r].Max(c => ((MarkdownTableCell)c).ContentHeight));
 
             tableContainer.RowDimensions = rowDefinitions;
         }