インデクサのしくみを“超ミニ実装”で覗いてみよう

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SimpleListLab
{
    public class SimpleList<T>
    {
        private T[] _items = new T[4];   // 初期容量
        private int _size = 0;           // 現在の要素数

        public int Count => _size;       // 読み取り専用プロパティ

        // ===== インデクサ =====
        public T this[int index]
        {
            get
            {
                if (index < 0 || index >= _size)
                    throw new ArgumentOutOfRangeException(nameof(index));
                return _items[index];
            }
            set
            {
                if (index < 0 || index >= _size)
                    throw new ArgumentOutOfRangeException(nameof(index));
                _items[index] = value;
            }
        }

        public void Add(T value)
        {
            if (_size == _items.Length) Resize(); // 満杯なら 2 倍
            _items[_size++] = value;
        }

        private void Resize()
        {
            var bigger = new T[_items.Length * 2];
            Array.Copy(_items, bigger, _items.Length);
            _items = bigger;
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            var nums = new SimpleList<int>();
            nums.Add(10);
            nums.Add(20);
            nums.Add(30);

            Console.WriteLine(nums[0]); // 10
            nums[1] = 99;
            Console.WriteLine(nums[1]); // 99
            Console.WriteLine($"Count = {nums.Count}"); // 3

            // Console.WriteLine(nums[3]); // IndexOutOfRange → 例外
        }
    }
}

以下は 「SimpleList」の改良版とイミュータブル版 のサンプル実装です。

• ① Range インデクサ（this[int start, int count]）
• ② 1.5 倍拡張ルール と 10 万 Add の割当回数テスト
• ③ 読み取り専用リスト（ReadOnlyList）

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

#region ① & ②  ─ 拡張版 SimpleList<T>
public class SimpleList<T> : IEnumerable<T>
{
    private T[] _items = new T[InitialCapacity];
    private int _size = 0;
    private int _allocations = 0;     // Resize 実行回数を記録

    private const int    InitialCapacity = 4;
    private const double GrowFactor      = 1.5;   // ★ 2 → 1.5 に変更 ★

    /*--- 通常インデクサ ---*/
    public T this[int index]
    {
        get => (index < 0 || index >= _size)
               ? throw new ArgumentOutOfRangeException(nameof(index))
               : _items[index];
        set
        {
            if (index < 0 || index >= _size)
                throw new ArgumentOutOfRangeException(nameof(index));
            _items[index] = value;
        }
    }

    /*--- ① Range インデクサ ---*/
    public IEnumerable<T> this[int start, int count]
    {
        get
        {
            if (start < 0 || count < 0 || start + count > _size)
                throw new ArgumentOutOfRangeException();
            for (int i = start; i < start + count; i++)
                yield return _items[i];
        }
    }

    public int  Count           => _size;
    public int  AllocationCount => _allocations;  // ② 計測用

    public void Add(T value)
    {
        if (_size == _items.Length) Resize();
        _items[_size++] = value;
    }

    private void Resize()
    {
        int newCap = (int)Math.Ceiling(_items.Length * GrowFactor);
        if (newCap == _items.Length) newCap++;    // 万一伸びなければ +1
        var bigger = new T[newCap];
        Array.Copy(_items, bigger, _items.Length);
        _items = bigger;
        _allocations++;                           // ② 計測用
    }

    /*--- IEnumerable<T> 実装 ---*/
    public IEnumerator<T> GetEnumerator()
    {
        for (int i = 0; i < _size; i++) yield return _items[i];
    }
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}
#endregion

#region ③ ─ イミュータブル ReadOnlyList<T>
public sealed class ReadOnlyList<T> : IEnumerable<T>
{
    private readonly T[] _items;

    public ReadOnlyList(params T[] items) =>
        _items = items ?? throw new ArgumentNullException(nameof(items));

    public int Count => _items.Length;

    public T this[int index] =>
        (index < 0 || index >= _items.Length)
        ? throw new ArgumentOutOfRangeException(nameof(index))
        : _items[index];

    public IEnumerator<T> GetEnumerator()
    {
        foreach (var x in _items) yield return x;
    }
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}
#endregion

/*========== デモ ==========*/
class Program
{
    static void Main()
    {
        // ② 10 万回 Add して割当回数を確認
        var big = new SimpleList<int>();
        for (int i = 0; i < 100_000; i++) big.Add(i);
        Console.WriteLine($"◆1.5 倍ルールの Resize 回数 = {big.AllocationCount}"); // → 26

        // ① Range インデクサの動作例
        Console.WriteLine(
            "◆500〜504 要素: " +
            string.Join(", ", big[500, 5])); // 500, 501, 502, 503, 504

        // ③ ReadOnlyList<T> の動作例
        var readOnly = new ReadOnlyList<string>("A", "B", "C");
        Console.WriteLine($"◆読み取り専用要素[1] = {readOnly[1]}"); // B
        Console.WriteLine(
            "◆全要素: " + string.Join(", ", readOnly));            // A, B, C
        // readOnly.Add("D"); // ← コンパイルエラー: メソッドが存在しない
    }
}

ポイント解説

結果まとめ

• 1.5 倍ルールは メモリ使用量と割当コストのトレードオフ。
• Range インデクサを追加すると LINQ に近いサブシーケンス操作 が簡単。
• イミュータブル版は 配列を丸ごと受け取る ことでコピーを省きつつ安全性を確保。

必要に応じて拡張・最適化してみてください。