C# 实现元素索引由１开始的链表

需求：

有以下场镜：在某个步骤控制类中，如果使用默认的List装载步骤对象，执行第一步的时候，对应的链表索引是0，界面上如果要显示执行进度，还要把索引值+1显示。

为了方便，修改List功能，第一个元素的索引就是1、第二个就是2、第三个就是3.......

实现方法：

最容易想到的是继承实现：

public class OneBasedList<T> : List<T>
{
    // 重写索引器
    public new T this[int index]
    {
        get
        {
            ValidateIndex(index);
            return base[index - 1];
        }
        set
        {
            ValidateIndex(index);
            base[index - 1] = value;
        }
    }
    
    private void ValidateIndex(int index)
    {
        if (index < 1 || index > Count)
        {
            throw new ArgumentOutOfRangeException(
                nameof(index), 
                $"索引 {index} 超出范围。有效范围: 1 到 {Count}"
            );
        }
    }
    
    // 重写ElementAt方法
    public new T ElementAt(int index)
    {
        ValidateIndex(index);
        return base[index - 1];
    }
    
    // 重写ElementAtOrDefault方法
    public new T ElementAtOrDefault(int index)
    {
        if (index < 1 || index > Count)
            return default(T);
        
        return base[index - 1];
    }
    
    // 重写其他相关方法
    public new int IndexOf(T item)
    {
        int zeroBasedIndex = base.IndexOf(item);
        return zeroBasedIndex >= 0 ? zeroBasedIndex + 1 : -1;
    }
    
    public new void Insert(int index, T item)
    {
        if (index < 1 || index > Count + 1)
            throw new ArgumentOutOfRangeException(nameof(index));
        
        base.Insert(index - 1, item);
    }
    
    public new void RemoveAt(int index)
    {
        ValidateIndex(index);
        base.RemoveAt(index - 1);
    }
    
    // 提供基于0的访问方法（如果需要）
    public T GetZeroBased(int zeroBasedIndex)
    {
        return base[zeroBasedIndex];
    }
}

通过new关键字覆盖特定的方法实现，但是这种实现方法有一定的风险，因为List开放的方法太多了，对应的以元素索引为参数的方法也很多，虽然这里覆盖了索引器和ElementAt等这些常用的，万一有一天使用到了其他没覆盖的方法，就会造成混乱；

这里推荐使用组合实现，在设计规则上也有组合优于继承一说。通过仅仅开放特定的方法来确保功能的正常使用。实现如下：

public class OneBasedList<T> : IEnumerable<T>
{
    private readonly List<T> _internalList;

    public OneBasedList()
    {
        _internalList = new List<T>();
    }

    public OneBasedList(IEnumerable<T> collection)
    {
        _internalList = new List<T>(collection);
    }

    public OneBasedList(int capacity)
    {
        _internalList = new List<T>(capacity);
    }

    // 基本属性
    public int Count => _internalList.Count;
    public int Capacity => _internalList.Capacity;

    // 基于1的索引器
    public T this[int index]
    {
        get
        {
            ValidateIndex(index);
            return _internalList[index - 1];
        }
        set
        {
            ValidateIndex(index);
            _internalList[index - 1] = value;
        }
    }

    // 核心方法 - 只开放必要的
    public void Add(T item) => _internalList.Add(item);
    
    public void AddRange(IEnumerable<T> collection) => _internalList.AddRange(collection);
    
    public void Clear() => _internalList.Clear();
    
    public bool Contains(T item) => _internalList.Contains(item);
    
    public void CopyTo(T[] array, int arrayIndex) => _internalList.CopyTo(array, arrayIndex);
    
    public int IndexOf(T item)
    {
        int index = _internalList.IndexOf(item);
        return index >= 0 ? index + 1 : -1;
    }
    
    public void Insert(int index, T item)
    {
        if (index < 1 || index > Count + 1)
            throw new ArgumentOutOfRangeException(nameof(index));
        _internalList.Insert(index - 1, item);
    }
    
    public bool Remove(T item) => _internalList.Remove(item);
    
    public void RemoveAt(int index)
    {
        ValidateIndex(index);
        _internalList.RemoveAt(index - 1);
    }

    // 基于1的ElementAt
    public T ElementAt(int index)
    {
        ValidateIndex(index);
        return _internalList[index - 1];
    }

    public T ElementAtOrDefault(int index)
    {
        if (index < 1 || index > Count)
            return default(T);
        return _internalList[index - 1];
    }

    // 查找方法
    public T Find(Predicate<T> match) => _internalList.Find(match);
    
    public List<T> FindAll(Predicate<T> match) => _internalList.FindAll(match);
    
    public int FindIndex(Predicate<T> match)
    {
        int index = _internalList.FindIndex(match);
        return index >= 0 ? index + 1 : -1;
    }

    // 枚举器
    public IEnumerator<T> GetEnumerator() => _internalList.GetEnumerator();
    
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

    // 验证方法
    private void ValidateIndex(int index)
    {
        if (index < 1 || index > Count)
            throw new ArgumentOutOfRangeException(nameof(index), $"索引必须在 1 到 {Count} 之间");
    }

    // 可选：提供一些便捷方法
    public T First() => _internalList.First();
    public T Last() => _internalList.Last();
    public bool Any() => _internalList.Any();

    // 可选：转换为数组或列表
    public T[] ToArray() => _internalList.ToArray();
    public List<T> ToList() => new List<T>(_internalList);

    // 可选：批量操作
    public void ForEach(Action<T> action) => _internalList.ForEach(action);
    
    public OneBasedList<T> GetRange(int index, int count)
    {
        ValidateIndex(index);
        if (count < 0 || index + count - 1 > Count)
            throw new ArgumentOutOfRangeException(nameof(count));
        
        var range = _internalList.GetRange(index - 1, count);
        return new OneBasedList<T>(range);
    }
}