Optimize: better random sampling for peers

src/Neo.Extensions/Collections/CollectionExtensions.cs

@@ -10,8 +10,10 @@
 // modifications are permitted.
 
 
+using Neo.Extensions.Factories;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Neo.Extensions
 {
@@ -76,5 +78,43 @@ public static IEnumerable<T[]> Chunk<T>(this IReadOnlyCollection<T>? source, int
                 yield return chunk;
             }
         }
+
+        /// <summary>
+        /// Randomly samples a specified number of elements from the collection using reservoir sampling algorithm.
+        /// This method ensures each element has an equal probability of being selected, regardless of the collection size.
+        /// If the count is greater than the collection size, the entire collection will be returned.
+        /// </summary>
+        /// <typeparam name="T">The type of the elements in the collection.</typeparam>
+        /// <param name="collection">The collection to sample from.</param>
+        /// <param name="count">The number of elements to sample.</param>
+        /// <returns>An array containing the randomly sampled elements.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when the collection is null.</exception>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown when the count is less than 0</exception>
+        [return: NotNull]
+        public static T[] Sample<T>(this IReadOnlyCollection<T> collection, int count)
+        {
+            ArgumentNullException.ThrowIfNull(collection);
+            ArgumentOutOfRangeException.ThrowIfLessThan(count, 0, nameof(count));
+
+            if (count == 0) return [];
+
+            var reservoir = new T[Math.Min(count, collection.Count)];
+            var currentIndex = 0;
+            foreach (var item in collection)
+            {
+                if (currentIndex < reservoir.Length)
+                {
+                    reservoir[currentIndex] = item;
+                }
+                else
+                {
+                    var randomIndex = RandomNumberFactory.NextInt32(0, currentIndex + 1);
+                    if (randomIndex < reservoir.Length) reservoir[randomIndex] = item;
+                }
+                currentIndex++;
+            }
+
+            return reservoir;
+        }
     }
 }

src/Neo/Network/P2P/Peer.cs

@@ -317,9 +317,7 @@ private void OnTimer()
             if (UnconnectedPeers.Count == 0)
                 NeedMorePeers(Config.MinDesiredConnections - ConnectedPeers.Count);
 
-            var endpoints = UnconnectedPeers.OrderBy(u => RandomNumberFactory.NextInt32())
-                .Take(Config.MinDesiredConnections - ConnectedPeers.Count)
-                .ToArray();
+            var endpoints = UnconnectedPeers.Sample(Config.MinDesiredConnections - ConnectedPeers.Count);
             ImmutableInterlocked.Update(ref UnconnectedPeers, p => p.Except(endpoints));
             foreach (var endpoint in endpoints)
             {

tests/Neo.Extensions.Tests/Collections/UT_CollectionExtensions.cs

@@ -78,5 +78,25 @@ public void TestRemoveWhere()
             Assert.AreEqual("a", dict[1]);
             Assert.AreEqual("c", dict[3]);
         }
+
+        [TestMethod]
+        public void TestSample()
+        {
+            var list = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+            var sampled = list.Sample(5);
+            Assert.AreEqual(5, sampled.Length);
+            foreach (var item in sampled) Assert.Contains(item, list);
+
+            sampled = list.Sample(10);
+            Assert.AreEqual(10, sampled.Length);
+            foreach (var item in sampled) Assert.Contains(item, list);
+
+            sampled = list.Sample(0);
+            Assert.AreEqual(0, sampled.Length);
+
+            sampled = list.Sample(100);
+            Assert.AreEqual(10, sampled.Length);
+            foreach (var item in sampled) Assert.Contains(item, list);
+        }
     }
 }