Mastering SortedList in C#

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;

namespace System.Collections.Generic
{
    [DebuggerDisplay("Count = {Count}")]
    [Serializable]
    public class SortedList<TKey, TValue> :
        IDictionary<TKey, TValue>,
        ICollection,
        IReadOnlyDictionary<TKey, TValue>
    {
        // Private Fields
        private TKey[] _keys;             // Stores all keys in sorted order
        private TValue[] _values;         // Stores values corresponding to each key
        private int _size;                // Number of elements in the list
        private IComparer<TKey> _comparer;// Defines how keys are compared (sorting logic)
        private KeyList? _keyList;        // Lazy wrapper for key collection
        private ValueList? _valueList;    // Lazy wrapper for value collection
        private int _version;             // Tracks modifications for enumerator safety
        private const int _defaultCapacity = 4; // Default capacity of arrays

        //  Constructors
        public SortedList()
            : this((IComparer<TKey>?)null)
        { }
        public SortedList(IComparer<TKey>? comparer)
        {
            _comparer = comparer ?? Comparer<TKey>.Default;
            _keys = Array.Empty<TKey>();
            _values = Array.Empty<TValue>();
            _size = 0;
        }
        public SortedList(int capacity)
            : this(capacity, null)
        { }
        public SortedList(int capacity, IComparer<TKey>? comparer)
        {
            if (capacity < 0)
                ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.capacity, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
            _comparer = comparer ?? Comparer<TKey>.Default;
            _keys = new TKey[capacity];
            _values = new TValue[capacity];
            _size = 0;
        }
        public SortedList(IDictionary<TKey, TValue> dictionary)
            : this(dictionary, null)
        { }
        public SortedList(IDictionary<TKey, TValue> dictionary, IComparer<TKey>? comparer)
            : this(dictionary?.Count ?? 0, comparer)
        {
            if (dictionary == null)
                ThrowHelper.ThrowArgumentNullException(ExceptionArgument.dictionary);

            foreach (KeyValuePair<TKey, TValue> pair in dictionary)
            {
                Add(pair.Key, pair.Value);
            }
        }

        // Public Properties
        public int Count => _size;
        public IComparer<TKey> Comparer => _comparer;
        public TKey[] Keys => _keys;
        public TValue[] Values => _values;
        public KeyList GetKeyList()
        {
            if (_keyList == null)
                _keyList = new KeyList(this);
            return _keyList;
        }

        public ValueList GetValueList()
        {
            if (_valueList == null)
                _valueList = new ValueList(this);
            return _valueList;
        }

        public TValue this[TKey key]
        {
            get
            {
                int i = IndexOfKey(key);
                if (i >= 0)
                    return _values[i];
                ThrowHelper.ThrowKeyNotFoundException(key);
                return default!; // Unreachable
            }
            set
            {
                if (key == null)
                    ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
                int i = Array.BinarySearch(_keys, 0, _size, key, _comparer);
                if (i >= 0)
                {
                    _values[i] = value;
                    _version++;
                    return;
                }
                Insert(~i, key, value);
            }
        }

        //  Explicit Interface Properties
        ICollection<TKey> IDictionary<TKey, TValue>.Keys
        {
            get
            {
                if (_keyList == null)
                    _keyList = new KeyList(this);
                return _keyList;
            }
        }

        ICollection<TValue> IDictionary<TKey, TValue>.Values
        {
            get
            {
                if (_valueList == null)
                    _valueList = new ValueList(this);
                return _valueList;
            }
        }

        IEnumerable<TKey> IReadOnlyDictionary<TKey, TValue>.Keys
        {
            get
            {
                if (_keyList == null)
                    _keyList = new KeyList(this);
                return _keyList;
            }
        }

        IEnumerable<TValue> IReadOnlyDictionary<TKey, TValue>.Values
        {
            get
            {
                if (_valueList == null)
                    _valueList = new ValueList(this);
                return _valueList;
            }
        }

        // Indexer (by position, internal use)
        internal TKey GetKey(int index)
        {
            if (index < 0 || index >= _size)
                ThrowHelper.ThrowArgumentOutOfRange_IndexException();
            return _keys[index];
        }

        internal TValue GetValue(int index)
        {
            if (index < 0 || index >= _size)
                ThrowHelper.ThrowArgumentOutOfRange_IndexException();
            return _values[index];
        }
    }
}