perf: replace O(n log n) OrderBy with O(n) reverse enumeration in HitObjectContainer; replace Single/SingleOrDefault with First/FirstOrDefault; fix OnlineStatusNotifier bindable leak

Agent-Logs-Url: https://github.com/winnerspiros/osu/sessions/b0878070-74cc-41e1-af2d-af6fb8954594

Co-authored-by: winnerspiros <1675249+winnerspiros@users.noreply.github.com>

Author: Copilot

osu.Game/Online/OnlineStatusNotifier.cs

@@ -161,6 +161,10 @@ protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
 
+            apiState?.UnbindAll();
+            multiplayerState?.UnbindAll();
+            spectatorState?.UnbindAll();
+
             if (notificationsClient.IsNotNull())
                 notificationsClient.MessageReceived -= notifyAboutForcedDisconnection;
 

osu.Game/Rulesets/UI/DrawableRuleset.cs

@@ -271,7 +271,7 @@ public bool RemoveHitObject(TObject hitObject)
                 return true;
 
             // If the entry was not removed from the playfield, assume the hitobject is not being pooled and attempt a direct drawable removal.
-            var drawableObject = Playfield.AllHitObjects.SingleOrDefault(d => d.HitObject == hitObject);
+            var drawableObject = Playfield.AllHitObjects.FirstOrDefault(d => d.HitObject == hitObject);
             if (drawableObject != null)
                 return Playfield.Remove(drawableObject);
 

osu.Game/Rulesets/UI/HitObjectContainer.cs

@@ -19,9 +19,42 @@ namespace osu.Game.Rulesets.UI
 {
     public partial class HitObjectContainer : PooledDrawableWithLifetimeContainer<HitObjectLifetimeEntry, DrawableHitObject>, IHitObjectContainer
     {
-        public IEnumerable<DrawableHitObject> Objects => InternalChildren.Cast<DrawableHitObject>().OrderBy(h => h.HitObject.StartTime);
+        /// <summary>
+        /// All <see cref="DrawableHitObject"/>s in this container, sorted by ascending <see cref="HitObject.StartTime"/>.
+        /// </summary>
+        /// <remarks>
+        /// Since internal children are already sorted by descending <see cref="HitObject.StartTime"/>
+        /// (via <see cref="Compare"/>), we reverse-enumerate to avoid an O(n log n) sort on every access.
+        /// </remarks>
+        public IEnumerable<DrawableHitObject> Objects => enumerateByStartTimeAscending();
+
+        /// <summary>
+        /// All alive <see cref="DrawableHitObject"/>s in this container, sorted by ascending <see cref="HitObject.StartTime"/>.
+        /// </summary>
+        /// <remarks>
+        /// The alive entries dictionary is unordered, so we must sort.
+        /// However, the alive set is typically much smaller than the full set, making this cheaper
+        /// than sorting all children. We use a List + Sort (in-place) to avoid LINQ iterator allocations.
+        /// </remarks>
+        public IEnumerable<DrawableHitObject> AliveObjects => getSortedAliveObjects();
+
+        private IEnumerable<DrawableHitObject> enumerateByStartTimeAscending()
+        {
+            var children = InternalChildren;
+
+            for (int i = children.Count - 1; i >= 0; i--)
+            {
+                if (children[i] is DrawableHitObject hitObject)
+                    yield return hitObject;
+            }
+        }
 
-        public IEnumerable<DrawableHitObject> AliveObjects => AliveEntries.Values.OrderBy(h => h.HitObject.StartTime);
+        private List<DrawableHitObject> getSortedAliveObjects()
+        {
+            var list = new List<DrawableHitObject>(AliveEntries.Values);
+            list.Sort(static (a, b) => a.HitObject.StartTime.CompareTo(b.HitObject.StartTime));
+            return list;
+        }
 
         /// <summary>
         /// Invoked when a <see cref="DrawableHitObject"/> is judged.

osu.Game/Screens/Edit/Compose/HitObjectUsageEventBuffer.cs

@@ -59,7 +59,7 @@ public HitObjectUsageEventBuffer([NotNull] Playfield playfield)
         private void onHitObjectUsageBegan(HitObject hitObject)
         {
             if (usageFinishedHitObjects.Remove(hitObject))
-                HitObjectUsageTransferred?.Invoke(hitObject, playfield.AllHitObjects.Single(d => d.HitObject == hitObject));
+                HitObjectUsageTransferred?.Invoke(hitObject, playfield.AllHitObjects.First(d => d.HitObject == hitObject));
             else
                 HitObjectUsageBegan?.Invoke(hitObject);
         }

osu.Game/Screens/Edit/GameplayTest/EditorPlayer.cs

@@ -131,7 +131,7 @@ void preventMiss(HitObject hitObject)
             {
                 var drawableObject = DrawableRuleset.Playfield.HitObjectContainer
                                                     .AliveObjects
-                                                    .SingleOrDefault(it => it.HitObject == hitObject);
+                                                    .FirstOrDefault(it => it.HitObject == hitObject);
 
                 if (drawableObject != null)
                     preventMissOnDrawable(drawableObject);