diff --git a/src/Neo/IO/Caching/Cache.cs b/src/Neo.IO/Caching/Cache.cs
similarity index 80%
rename from src/Neo/IO/Caching/Cache.cs
rename to src/Neo.IO/Caching/Cache.cs
index 7895a8ca2d..1a66e6dca5 100644
--- a/src/Neo/IO/Caching/Cache.cs
+++ b/src/Neo.IO/Caching/Cache.cs
@@ -17,25 +17,21 @@
 
 namespace Neo.IO.Caching
 {
-    internal abstract class Cache<TKey, TValue> : ICollection<TValue>, IDisposable
+    internal abstract class Cache<TKey, TValue>
+        (int max_capacity, IEqualityComparer<TKey>? comparer = null) : ICollection<TValue>, IDisposable
+        where TKey : notnull
     {
         protected class CacheItem
+            (TKey key, TValue value)
         {
-            public readonly TKey Key;
-            public readonly TValue Value;
-            public readonly DateTime Time;
-
-            public CacheItem(TKey key, TValue value)
-            {
-                Key = key;
-                Value = value;
-                Time = TimeProvider.Current.UtcNow;
-            }
+            public readonly TKey Key = key;
+            public readonly TValue Value = value;
+            public readonly DateTime Time = DateTime.UtcNow;
         }
 
         protected readonly ReaderWriterLockSlim RwSyncRootLock = new(LockRecursionPolicy.SupportsRecursion);
-        protected readonly Dictionary<TKey, CacheItem> InnerDictionary;
-        private readonly int max_capacity;
+        protected readonly Dictionary<TKey, CacheItem> InnerDictionary = new Dictionary<TKey, CacheItem>(comparer);
+        private readonly int _max_capacity = max_capacity;
 
         public TValue this[TKey key]
         {
@@ -44,7 +40,7 @@ public TValue this[TKey key]
                 RwSyncRootLock.EnterReadLock();
                 try
                 {
-                    if (!InnerDictionary.TryGetValue(key, out CacheItem item)) throw new KeyNotFoundException();
+                    if (!InnerDictionary.TryGetValue(key, out CacheItem? item)) throw new KeyNotFoundException();
                     OnAccess(item);
                     return item.Value;
                 }
@@ -73,15 +69,9 @@ public int Count
 
         public bool IsReadOnly => false;
 
-        public Cache(int max_capacity, IEqualityComparer<TKey> comparer = null)
-        {
-            this.max_capacity = max_capacity;
-            InnerDictionary = new Dictionary<TKey, CacheItem>(comparer);
-        }
-
         public void Add(TValue item)
         {
-            TKey key = GetKeyForItem(item);
+            var key = GetKeyForItem(item);
             RwSyncRootLock.EnterWriteLock();
             try
             {
@@ -95,16 +85,16 @@ public void Add(TValue item)
 
         private void AddInternal(TKey key, TValue item)
         {
-            if (InnerDictionary.TryGetValue(key, out CacheItem cacheItem))
+            if (InnerDictionary.TryGetValue(key, out CacheItem? cacheItem))
             {
                 OnAccess(cacheItem);
             }
             else
             {
-                if (InnerDictionary.Count >= max_capacity)
+                if (InnerDictionary.Count >= _max_capacity)
                 {
                     //TODO: Perform a performance test on the PLINQ query to determine which algorithm is better here (parallel or not)
-                    foreach (CacheItem item_del in InnerDictionary.Values.AsParallel().OrderBy(p => p.Time).Take(InnerDictionary.Count - max_capacity + 1))
+                    foreach (var item_del in InnerDictionary.Values.AsParallel().OrderBy(p => p.Time).Take(InnerDictionary.Count - _max_capacity + 1))
                     {
                         RemoveInternal(item_del);
                     }
@@ -118,9 +108,9 @@ public void AddRange(IEnumerable<TValue> items)
             RwSyncRootLock.EnterWriteLock();
             try
             {
-                foreach (TValue item in items)
+                foreach (var item in items)
                 {
-                    TKey key = GetKeyForItem(item);
+                    var key = GetKeyForItem(item);
                     AddInternal(key, item);
                 }
             }
@@ -135,7 +125,7 @@ public void Clear()
             RwSyncRootLock.EnterWriteLock();
             try
             {
-                foreach (CacheItem item_del in InnerDictionary.Values.ToArray())
+                foreach (var item_del in InnerDictionary.Values.ToArray())
                 {
                     RemoveInternal(item_del);
                 }
@@ -151,7 +141,7 @@ public bool Contains(TKey key)
             RwSyncRootLock.EnterReadLock();
             try
             {
-                if (!InnerDictionary.TryGetValue(key, out CacheItem cacheItem)) return false;
+                if (!InnerDictionary.TryGetValue(key, out CacheItem? cacheItem)) return false;
                 OnAccess(cacheItem);
                 return true;
             }
@@ -171,7 +161,7 @@ public void CopyTo(TValue[] array, int arrayIndex)
             if (array == null) throw new ArgumentNullException();
             if (arrayIndex < 0) throw new ArgumentOutOfRangeException();
             if (arrayIndex + InnerDictionary.Count > array.Length) throw new ArgumentException();
-            foreach (TValue item in this)
+            foreach (var item in this)
             {
                 array[arrayIndex++] = item;
             }
@@ -188,7 +178,7 @@ public IEnumerator<TValue> GetEnumerator()
             RwSyncRootLock.EnterReadLock();
             try
             {
-                foreach (TValue item in InnerDictionary.Values.Select(p => p.Value))
+                foreach (var item in InnerDictionary.Values.Select(p => p.Value))
                 {
                     yield return item;
                 }
@@ -211,7 +201,7 @@ public bool Remove(TKey key)
             RwSyncRootLock.EnterWriteLock();
             try
             {
-                if (!InnerDictionary.TryGetValue(key, out CacheItem cacheItem)) return false;
+                if (!InnerDictionary.TryGetValue(key, out CacheItem? cacheItem)) return false;
                 RemoveInternal(cacheItem);
                 return true;
             }
@@ -242,7 +232,7 @@ public bool TryGet(TKey key, out TValue item)
             RwSyncRootLock.EnterReadLock();
             try
             {
-                if (InnerDictionary.TryGetValue(key, out CacheItem cacheItem))
+                if (InnerDictionary.TryGetValue(key, out CacheItem? cacheItem))
                 {
                     OnAccess(cacheItem);
                     item = cacheItem.Value;
@@ -253,7 +243,7 @@ public bool TryGet(TKey key, out TValue item)
             {
                 RwSyncRootLock.ExitReadLock();
             }
-            item = default;
+            item = default!;
             return false;
         }
     }
diff --git a/src/Neo/IO/Caching/FIFOCache.cs b/src/Neo.IO/Caching/FIFOCache.cs
similarity index 72%
rename from src/Neo/IO/Caching/FIFOCache.cs
rename to src/Neo.IO/Caching/FIFOCache.cs
index af3e5e469d..b7e9f39e98 100644
--- a/src/Neo/IO/Caching/FIFOCache.cs
+++ b/src/Neo.IO/Caching/FIFOCache.cs
@@ -13,13 +13,10 @@
 
 namespace Neo.IO.Caching
 {
-    internal abstract class FIFOCache<TKey, TValue> : Cache<TKey, TValue>
+    internal abstract class FIFOCache<TKey, TValue>
+        (int max_capacity, IEqualityComparer<TKey>? comparer = null) : Cache<TKey, TValue>(max_capacity, comparer)
+        where TKey : notnull
     {
-        public FIFOCache(int max_capacity, IEqualityComparer<TKey> comparer = null)
-            : base(max_capacity, comparer)
-        {
-        }
-
         protected override void OnAccess(CacheItem item)
         {
         }
diff --git a/src/Neo/IO/Caching/HashSetCache.cs b/src/Neo.IO/Caching/HashSetCache.cs
similarity index 76%
rename from src/Neo/IO/Caching/HashSetCache.cs
rename to src/Neo.IO/Caching/HashSetCache.cs
index bdef1c5e3a..577893e924 100644
--- a/src/Neo/IO/Caching/HashSetCache.cs
+++ b/src/Neo.IO/Caching/HashSetCache.cs
@@ -20,17 +20,17 @@ class HashSetCache<T> : IReadOnlyCollection<T> where T : IEquatable<T>
         /// <summary>
         /// Sets where the Hashes are stored
         /// </summary>
-        private readonly LinkedList<HashSet<T>> sets = new();
+        private readonly LinkedList<HashSet<T>> _sets = new();
 
         /// <summary>
-        /// Maximum capacity of each bucket inside each HashSet of <see cref="sets"/>.
+        /// Maximum capacity of each bucket inside each HashSet of <see cref="_sets"/>.
         /// </summary>
-        private readonly int bucketCapacity;
+        private readonly int _bucketCapacity;
 
         /// <summary>
         /// Maximum number of buckets for the LinkedList, meaning its maximum cardinality.
         /// </summary>
-        private readonly int maxBucketCount;
+        private readonly int _maxBucketCount;
 
         /// <summary>
         /// Entry count
@@ -43,32 +43,32 @@ public HashSetCache(int bucketCapacity, int maxBucketCount = 10)
             if (maxBucketCount <= 0) throw new ArgumentOutOfRangeException($"{nameof(maxBucketCount)} should be greater than 0");
 
             Count = 0;
-            this.bucketCapacity = bucketCapacity;
-            this.maxBucketCount = maxBucketCount;
-            sets.AddFirst(new HashSet<T>());
+            _bucketCapacity = bucketCapacity;
+            _maxBucketCount = maxBucketCount;
+            _sets.AddFirst([]);
         }
 
         public bool Add(T item)
         {
             if (Contains(item)) return false;
             Count++;
-            if (sets.First.Value.Count < bucketCapacity) return sets.First.Value.Add(item);
+            if (_sets.First?.Value.Count < _bucketCapacity) return _sets.First.Value.Add(item);
             var newSet = new HashSet<T>
             {
                 item
             };
-            sets.AddFirst(newSet);
-            if (sets.Count > maxBucketCount)
+            _sets.AddFirst(newSet);
+            if (_sets.Count > _maxBucketCount)
             {
-                Count -= sets.Last.Value.Count;
-                sets.RemoveLast();
+                Count -= _sets.Last?.Value.Count ?? 0;
+                _sets.RemoveLast();
             }
             return true;
         }
 
         public bool Contains(T item)
         {
-            foreach (var set in sets)
+            foreach (var set in _sets)
             {
                 if (set.Contains(item)) return true;
             }
@@ -77,17 +77,17 @@ public bool Contains(T item)
 
         public void ExceptWith(IEnumerable<T> items)
         {
-            List<HashSet<T>> removeList = null;
+            List<HashSet<T>> removeList = default!;
             foreach (var item in items)
             {
-                foreach (var set in sets)
+                foreach (var set in _sets)
                 {
                     if (set.Remove(item))
                     {
                         Count--;
                         if (set.Count == 0)
                         {
-                            removeList ??= new List<HashSet<T>>();
+                            removeList ??= [];
                             removeList.Add(set);
                         }
                         break;
@@ -97,13 +97,13 @@ public void ExceptWith(IEnumerable<T> items)
             if (removeList == null) return;
             foreach (var set in removeList)
             {
-                sets.Remove(set);
+                _sets.Remove(set);
             }
         }
 
         public IEnumerator<T> GetEnumerator()
         {
-            foreach (var set in sets)
+            foreach (var set in _sets)
             {
                 foreach (var item in set)
                 {
diff --git a/src/Neo/IO/Caching/IndexedQueue.cs b/src/Neo.IO/Caching/IndexedQueue.cs
similarity index 95%
rename from src/Neo/IO/Caching/IndexedQueue.cs
rename to src/Neo.IO/Caching/IndexedQueue.cs
index 54440a871b..29b39a4947 100644
--- a/src/Neo/IO/Caching/IndexedQueue.cs
+++ b/src/Neo.IO/Caching/IndexedQueue.cs
@@ -89,14 +89,14 @@ public void Enqueue(T item)
         {
             if (_array.Length == _count)
             {
-                int newSize = _array.Length * GrowthFactor;
+                var newSize = _array.Length * GrowthFactor;
                 if (_head == 0)
                 {
                     Array.Resize(ref _array, newSize);
                 }
                 else
                 {
-                    T[] buffer = new T[newSize];
+                    var buffer = new T[newSize];
                     Array.Copy(_array, _head, buffer, 0, _array.Length - _head);
                     Array.Copy(_array, 0, buffer, _array.Length - _head, _head);
                     _array = buffer;
@@ -127,7 +127,7 @@ public bool TryPeek(out T item)
         {
             if (_count == 0)
             {
-                item = default;
+                item = default!;
                 return false;
             }
             else
@@ -145,7 +145,7 @@ public T Dequeue()
         {
             if (_count == 0)
                 throw new InvalidOperationException("The queue is empty");
-            T result = _array[_head];
+            var result = _array[_head];
             ++_head;
             _head %= _array.Length;
             --_count;
@@ -161,7 +161,7 @@ public bool TryDequeue(out T item)
         {
             if (_count == 0)
             {
-                item = default;
+                item = default!;
                 return false;
             }
             else
@@ -194,7 +194,7 @@ public void TrimExcess()
             }
             else if (_array.Length * TrimThreshold >= _count)
             {
-                T[] arr = new T[_count];
+                var arr = new T[_count];
                 CopyTo(arr, 0);
                 _array = arr;
                 _head = 0;
@@ -228,14 +228,14 @@ public void CopyTo(T[] array, int arrayIndex)
         /// <returns>An array containing the queue's items</returns>
         public T[] ToArray()
         {
-            T[] result = new T[_count];
+            var result = new T[_count];
             CopyTo(result, 0);
             return result;
         }
 
         public IEnumerator<T> GetEnumerator()
         {
-            for (int i = 0; i < _count; i++)
+            for (var i = 0; i < _count; i++)
                 yield return _array[(_head + i) % _array.Length];
         }
 
diff --git a/src/Neo/IO/Caching/KeyedCollectionSlim.cs b/src/Neo.IO/Caching/KeyedCollectionSlim.cs
similarity index 61%
rename from src/Neo/IO/Caching/KeyedCollectionSlim.cs
rename to src/Neo.IO/Caching/KeyedCollectionSlim.cs
index a24dd87e4c..f632dc0927 100644
--- a/src/Neo/IO/Caching/KeyedCollectionSlim.cs
+++ b/src/Neo.IO/Caching/KeyedCollectionSlim.cs
@@ -10,43 +10,46 @@
 // modifications are permitted.
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 
 namespace Neo.IO.Caching;
 
-abstract class KeyedCollectionSlim<TKey, TItem> where TKey : notnull
+abstract class KeyedCollectionSlim<TKey, TItem>
+    where TKey : notnull
+    where TItem : class, IStructuralEquatable, IStructuralComparable, IComparable
 {
     private readonly LinkedList<TItem> _items = new();
-    private readonly Dictionary<TKey, LinkedListNode<TItem>> dict = new();
+    private readonly Dictionary<TKey, LinkedListNode<TItem>> _dict = [];
 
-    public int Count => dict.Count;
-    public TItem First => _items.First.Value;
+    public int Count => _dict.Count;
+    public TItem? First => _items.First?.Value;
 
-    protected abstract TKey GetKeyForItem(TItem item);
+    protected abstract TKey GetKeyForItem(TItem? item);
 
     public void Add(TItem item)
     {
         var key = GetKeyForItem(item);
         var node = _items.AddLast(item);
-        if (!dict.TryAdd(key, node))
+        if (!_dict.TryAdd(key, node))
         {
             _items.RemoveLast();
             throw new ArgumentException("An element with the same key already exists in the collection.");
         }
     }
 
-    public bool Contains(TKey key) => dict.ContainsKey(key);
+    public bool Contains(TKey key) => _dict.ContainsKey(key);
 
     public void Remove(TKey key)
     {
-        if (dict.Remove(key, out var node))
+        if (_dict.Remove(key, out var node))
             _items.Remove(node);
     }
 
     public void RemoveFirst()
     {
-        var key = GetKeyForItem(_items.First.Value);
-        dict.Remove(key);
+        var key = GetKeyForItem(_items.First?.Value);
+        _dict.Remove(key);
         _items.RemoveFirst();
     }
 }
diff --git a/src/Neo/Cryptography/Crypto.cs b/src/Neo/Cryptography/Crypto.cs
index 85ed0411a8..a2e89dc787 100644
--- a/src/Neo/Cryptography/Crypto.cs
+++ b/src/Neo/Cryptography/Crypto.cs
@@ -170,7 +170,7 @@ public static ECDsa CreateECDsa(ECC.ECPoint pubkey)
         {
             if (CacheECDsa.TryGet(pubkey, out var cache))
             {
-                return cache.value;
+                return cache.Value;
             }
             var curve =
                 pubkey.Curve == ECC.ECCurve.Secp256r1 ? ECCurve.NamedCurves.nistP256 :
diff --git a/src/Neo/IO/Caching/ECDsaCache.cs b/src/Neo/IO/Caching/ECDsaCache.cs
index b25f29da8e..b41a058b61 100644
--- a/src/Neo/IO/Caching/ECDsaCache.cs
+++ b/src/Neo/IO/Caching/ECDsaCache.cs
@@ -14,7 +14,8 @@
 
 namespace Neo.IO.Caching
 {
-    record ECDsaCacheItem(Cryptography.ECC.ECPoint key, ECDsa value);
+    record ECDsaCacheItem(Cryptography.ECC.ECPoint Key, ECDsa Value);
+
     internal class ECDsaCache : FIFOCache<Cryptography.ECC.ECPoint, ECDsaCacheItem>
     {
         public ECDsaCache(int max_capacity = 20000) : base(max_capacity, EqualityComparer<Cryptography.ECC.ECPoint>.Default)
@@ -23,7 +24,7 @@ public ECDsaCache(int max_capacity = 20000) : base(max_capacity, EqualityCompare
 
         protected override Cryptography.ECC.ECPoint GetKeyForItem(ECDsaCacheItem item)
         {
-            return item.key;
+            return item.Key;
         }
     }
 }
diff --git a/src/Neo/Network/P2P/RemoteNode.ProtocolHandler.cs b/src/Neo/Network/P2P/RemoteNode.ProtocolHandler.cs
index 4606723cd0..4e7861a562 100644
--- a/src/Neo/Network/P2P/RemoteNode.ProtocolHandler.cs
+++ b/src/Neo/Network/P2P/RemoteNode.ProtocolHandler.cs
@@ -30,9 +30,9 @@ namespace Neo.Network.P2P
     partial class RemoteNode
     {
         private class Timer { }
-        private class PendingKnownHashesCollection : KeyedCollectionSlim<UInt256, (UInt256, DateTime)>
+        private class PendingKnownHashesCollection : KeyedCollectionSlim<UInt256, Tuple<UInt256, DateTime>>
         {
-            protected override UInt256 GetKeyForItem((UInt256, DateTime) item)
+            protected override UInt256 GetKeyForItem(Tuple<UInt256, DateTime> item)
             {
                 return item.Item1;
             }
@@ -354,7 +354,7 @@ private void OnInvMessageReceived(InvPayload payload)
             }
             if (hashes.Length == 0) return;
             foreach (UInt256 hash in hashes)
-                pendingKnownHashes.Add((hash, TimeProvider.Current.UtcNow));
+                pendingKnownHashes.Add(Tuple.Create(hash, TimeProvider.Current.UtcNow));
             system.TaskManager.Tell(new TaskManager.NewTasks { Payload = InvPayload.Create(payload.Type, hashes) });
         }