More robust data structures

src/Transit/Impl/ListWrapper.cs

@@ -0,0 +1,8 @@
+namespace Transit.Net.Impl;
+
+/// <summary>
+/// A wrapper class for lists, to semantically preserve how the list should be serialized.
+/// Normally things tagged with "list" would be interpreted as LinkedLists, but in C# we want to
+/// use regular Lists for performance.
+/// </summary>
+internal sealed class ListWrapper : List<object?>;

src/Transit/Impl/NullKeyDictionary.cs

@@ -1,12 +1,13 @@
 using System.Collections;
+using System.Collections.Generic;
 
 namespace Transit.Net.Impl;
 
 /// <summary>
 /// A dictionary that supports null keys, matching Java's HashMap behavior.
 /// Used by cmap (composite-key map) read handling where null can be a valid key.
 /// </summary>
-internal sealed class NullKeyDictionary : IDictionary
+internal sealed class NullKeyDictionary : IDictionary, IDictionary<object?, object?>, IReadOnlyDictionary<object?, object?>
 {
     private readonly Dictionary<object, object?> _inner = new();
     private bool _hasNullKey;
@@ -26,14 +27,20 @@
 
     public int Count => _inner.Count + (_hasNullKey ? 1 : 0);
 
-    public bool Contains(object? key)
+    public bool ContainsKey(object? key)
         => key is null ? _hasNullKey : _inner.ContainsKey(key);
 
-    public ICollection Keys
+    bool IDictionary.Contains(object? key) => ContainsKey(key);
+
+    bool ICollection<KeyValuePair<object?, object?>>.Contains(KeyValuePair<object?, object?> kvp) => kvp.Key is null
+        ? _hasNullKey && EqualityComparer<object>.Default.Equals(kvp.Value, _nullValue)
+        : ((ICollection<KeyValuePair<object, object?>>)_inner).Contains(kvp);
+
+    public ICollection<object?> Keys
     {
         get
         {
             if (!_hasNullKey) return _inner.Keys;
             var keys = new List<object?>(_inner.Count + 1);
             foreach (var k in _inner.Keys) keys.Add(k);
             keys.Add(null);
@@ -41,38 +48,85 @@
         }
     }
 
-    public ICollection Values
+    IEnumerable<object?> IReadOnlyDictionary<object?, object?>.Keys => Keys;
+
+    ICollection IDictionary.Keys => (ICollection)Keys;
+
+    public ICollection<object?> Values
     {
         get
         {
-            if (!_hasNullKey) return (ICollection)_inner.Values;
+            if (!_hasNullKey) return _inner.Values;
             var values = new List<object?>(_inner.Count + 1);
             foreach (var v in _inner.Values) values.Add(v);
             values.Add(_nullValue);
             return values;
         }
     }
 
+    IEnumerable<object?> IReadOnlyDictionary<object?, object?>.Values => Values;
+
+    ICollection IDictionary.Values => (ICollection)Values;
+
     public bool IsFixedSize => false;
     public bool IsReadOnly => false;
     public bool IsSynchronized => false;
     public object SyncRoot => this;
 
     public void Add(object key, object? value) => this[key] = value;
+
+    void ICollection<KeyValuePair<object?, object?>>.Add(KeyValuePair<object?, object?> kvp) => Add(kvp.Key, kvp.Value);
+
     public void Clear() { _inner.Clear(); _hasNullKey = false; _nullValue = null; }
-    public void Remove(object key)
+
+    public bool Remove(object? key)
     {
-        if (key is null) { _hasNullKey = false; _nullValue = null; }
-        else _inner.Remove(key);
+        if (key is null)
+        {
+            if (_hasNullKey)
+            {
+                _hasNullKey = false;
+                _nullValue = null;
+                return true;
+            }
+            return false;
+        }
+        return _inner.Remove(key);
     }
 
+    void IDictionary.Remove(object key) => Remove(key);
+
+    bool ICollection<KeyValuePair<object?, object?>>.Remove(KeyValuePair<object?, object?> item)
+        => throw new NotImplementedException();
+
     public void CopyTo(Array array, int index) => throw new NotImplementedException();
 
+    void ICollection<KeyValuePair<object?, object?>>.CopyTo(KeyValuePair<object?, object?>[] array, int arrayIndex)
+        => throw new NotImplementedException();
+
     public IDictionaryEnumerator GetEnumerator() => new NullKeyEnumerator(this);
 
     IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
-    private sealed class NullKeyEnumerator : IDictionaryEnumerator
+    IEnumerator<KeyValuePair<object?, object?>> IEnumerable<KeyValuePair<object?, object?>>.GetEnumerator()
+        => new NullKeyEnumerator(this);
+
+    public bool TryGetValue(object? key, out object? value)
+    {
+        if (key is null)
+        {
+            if (_hasNullKey)
+            {
+                value = _nullValue;
+                return true;
+            }
+            value = default;
+            return false;
+        }
+        return _inner.TryGetValue(key, out value);
+    }
+
+    private sealed class NullKeyEnumerator : IDictionaryEnumerator, IEnumerator<KeyValuePair<object?, object?>>
     {
         private readonly NullKeyDictionary _dict;
         private readonly IEnumerator<KeyValuePair<object, object?>> _innerEnum;
@@ -93,6 +147,12 @@
         public object? Value => Entry.Value;
         public object Current => Entry;
 
+        KeyValuePair<object?, object?> IEnumerator<KeyValuePair<object?, object?>>.Current => _onNull
+            ? new KeyValuePair<object?, object?>(null!, _dict._nullValue)
+            : new KeyValuePair<object?, object?>(_innerEnum.Current.Key, _innerEnum.Current.Value);
+
+        public void Dispose() { }
+
         public bool MoveNext()
         {
             if (_innerEnum.MoveNext()) { _onNull = false; return true; }

src/Transit/Impl/ReadHandlers/ReadHandlers.cs

@@ -136,12 +136,12 @@ internal sealed class ListReadHandler : IListReadHandler
 {
     public object FromRepresentation(object representation) => representation;
 
-    public IListReader ListReader() => new LinkedListReader();
+    public IListReader ListReader() => new ListWrapperReader();
 
-    private sealed class LinkedListReader : IListReader
+    private sealed class ListWrapperReader : IListReader
     {
-        public object Init() => new LinkedList<object>();
-        public object Add(object list, object item) { ((LinkedList<object>)list).AddLast(item); return list; }
+        public object Init() => new ListWrapper();
+        public object Add(object list, object item) { ((ListWrapper)list).Add(item); return list; }
         public object Complete(object list) => list;
     }
 }

src/Transit/Impl/WriterFactory.cs

@@ -47,6 +47,7 @@ private static FrozenDictionary<Type, IWriteHandler> BuildDefaultHandlers()
             [typeof(ITaggedValue)] = new TaggedValueWriteHandler(),
             [typeof(ISet<>)] = new SetWriteHandler(),
             [typeof(IEnumerable)] = new EnumerableWriteHandler(),
+            [typeof(ListWrapper)] = new EnumerableWriteHandler(),
             [typeof(IList<>)] = listHandler,
             [typeof(IDictionary<,>)] = new DictionaryWriteHandler(),
             [typeof(NullKeyDictionary)] = new DictionaryWriteHandler(),