public class OrderedDictionary<TKey, TValue> : IDictionary<TKey, TValue>
    {
        private readonly List<KeyValuePair<TKey, TValue>> _list = new();
        private readonly Dictionary<TKey, int> _indexMap = new();

        public OrderedDictionary() { }

        public TValue this[TKey key]
        {
            get
            {
                if (!_indexMap.TryGetValue(key, out var index))
                    throw new KeyNotFoundException();
                return _list[index].Value;
            }
            set
            {
                if (_indexMap.TryGetValue(key, out var index))
                {
                    _list[index] = new KeyValuePair<TKey, TValue>(key, value);
                }
                else
                {
                    _indexMap[key] = _list.Count;
                    _list.Add(new KeyValuePair<TKey, TValue>(key, value));
                }
            }
        }

        public ICollection<TKey> Keys => _list.Select(kv => kv.Key).ToList();
        public ICollection<TValue> Values => _list.Select(kv => kv.Value).ToList();
        public int Count => _list.Count;
        public bool IsReadOnly => false;

        public void Add(TKey key, TValue value)
        {
            if (_indexMap.ContainsKey(key))
                throw new ArgumentException("Key already exists");
            _indexMap[key] = _list.Count;
            _list.Add(new KeyValuePair<TKey, TValue>(key, value));
        }

        public bool ContainsKey(TKey key) => _indexMap.ContainsKey(key);

        public bool Remove(TKey key)
        {
            if (!_indexMap.TryGetValue(key, out var index))
                return false;

            _list.RemoveAt(index);
            _indexMap.Remove(key);
            
            for (var i = index; i < _list.Count; i++)
            {
                _indexMap[_list[i].Key] = i;
            }

            return true;
        }

        public bool TryGetValue(TKey key, out TValue value)
        {
            if (_indexMap.TryGetValue(key, out var index))
            {
                value = _list[index].Value;
                return true;
            }

            value = default;
            return false;
        }

        public void Clear()
        {
            _list.Clear();
            _indexMap.Clear();
        }

        public void Add(KeyValuePair<TKey, TValue> item) => Add(item.Key, item.Value);
        public bool Contains(KeyValuePair<TKey, TValue> item)
        {
            return TryGetValue(item.Key, out var value) &&
                   EqualityComparer<TValue>.Default.Equals(value, item.Value);
        }

        public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
        {
            _list.CopyTo(array, arrayIndex);
        }

        public bool Remove(KeyValuePair<TKey, TValue> item)
        {
            return Contains(item) && Remove(item.Key);
        }

        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() => _list.GetEnumerator();
        IEnumerator IEnumerable.GetEnumerator() => _list.GetEnumerator();
    }

[MessagePackObject]
public class MyObject
{
    //[Key(0)] public Dictionary<byte, byte> Dict{ get; set; }
    [Key(0)] public OrderedDictionary<byte, byte> Dict{ get; set; }
}