Reduce allocation overhead for keyboard / binding / button handling

osu.Framework/Input/Bindings/KeyBindingContainer.cs

@@ -202,6 +202,8 @@ private bool handleRepeat(InputState state)
             return drawables.FirstOrDefault(d => triggerKeyBindingEvent(d, pressEvent)) != null;
         }
 
+        private readonly List<IKeyBinding> newlyPressed = new List<IKeyBinding>();
+
         private bool handleNewPressed(InputState state, InputKey newKey, Vector2? scrollDelta = null, bool isPrecise = false)
         {
             pressedInputKeys.Add(newKey);
@@ -210,21 +212,36 @@ private bool handleNewPressed(InputState state, InputKey newKey, Vector2? scroll
             var pressedCombination = new KeyCombination(pressedInputKeys);
 
             bool handled = false;
-            var bindings = KeyBindings?.Except(pressedBindings) ?? Enumerable.Empty<IKeyBinding>();
-            var newlyPressed = bindings.Where(m =>
-                m.KeyCombination.IsPressed(pressedCombination, matchingMode));
+
+            newlyPressed.Clear();
+
+            if (KeyBindings != null)
+            {
+                foreach (IKeyBinding binding in KeyBindings)
+                {
+                    if (pressedBindings.Contains(binding))
+                        continue;
+
+                    if (binding.KeyCombination.IsPressed(pressedCombination, matchingMode))
+                        newlyPressed.Add(binding);
+                }
+            }
 
             if (KeyCombination.IsModifierKey(newKey))
             {
                 // if the current key pressed was a modifier, only handle modifier-only bindings.
                 // lambda expression is used so that the delegate is cached (see: https://github.com/dotnet/roslyn/issues/5835)
                 // TODO: remove when we switch to .NET 7.
                 // ReSharper disable once ConvertClosureToMethodGroup
-                newlyPressed = newlyPressed.Where(b => b.KeyCombination.Keys.All(key => KeyCombination.IsModifierKey(key)));
+                for (int i = 0; i < newlyPressed.Count; i++)
+                {
+                    if (!newlyPressed[i].KeyCombination.Keys.All(key => KeyCombination.IsModifierKey(key)))
+                        newlyPressed.RemoveAt(i--);
+                }
             }
 
             // we want to always handle bindings with more keys before bindings with less.
-            newlyPressed = newlyPressed.OrderByDescending(b => b.KeyCombination.Keys.Length).ToList();
+            newlyPressed.Sort(static (a, b) => b.KeyCombination.Keys.Length.CompareTo(a.KeyCombination.Keys.Length));
 
             pressedBindings.AddRange(newlyPressed);
 
@@ -342,16 +359,16 @@ private void handleNewReleased(InputState state, InputKey releasedKey)
             // we don't want to consider exact matching here as we are dealing with bindings, not actions.
             var pressedCombination = new KeyCombination(pressedInputKeys);
 
-            var newlyReleased = pressedInputKeys.Count == 0
-                ? pressedBindings.ToList()
-                : pressedBindings.Where(b => !b.KeyCombination.IsPressed(pressedCombination, KeyCombinationMatchingMode.Any)).ToList();
-
-            foreach (var binding in newlyReleased)
+            for (int i = 0; i < pressedBindings.Count; i++)
             {
-                pressedBindings.Remove(binding);
+                var binding = pressedBindings[i];
 
-                PropagateReleased(getInputQueue(binding).Where(d => d.IsRootedAt(this)), state, binding.GetAction<T>());
-                keyBindingQueues[binding].Clear();
+                if (pressedInputKeys.Count == 0 || !binding.KeyCombination.IsPressed(pressedCombination, KeyCombinationMatchingMode.Any))
+                {
+                    pressedBindings.RemoveAt(i--);
+                    PropagateReleased(getInputQueue(binding).Where(d => d.IsRootedAt(this)), state, binding.GetAction<T>());
+                    keyBindingQueues[binding].Clear();
+                }
             }
         }
 

osu.Framework/Input/Bindings/KeyCombination.cs

@@ -29,10 +29,25 @@ namespace osu.Framework.Input.Bindings
         /// Construct a new instance.
         /// </summary>
         /// <param name="keys">The keys.</param>
-        /// <remarks>This constructor is not optimized. Hot paths are assumed to use <see cref="FromInputState(InputState, Vector2?)"/>.</remarks>
-        public KeyCombination(IEnumerable<InputKey>? keys)
+        public KeyCombination(ICollection<InputKey>? keys)
         {
-            Keys = keys?.Any() == true ? keys.Distinct().OrderBy(k => (int)k).ToImmutableArray() : none;
+            if (keys == null || !keys.Any())
+            {
+                Keys = none;
+                return;
+            }
+
+            var keyBuilder = ImmutableArray.CreateBuilder<InputKey>(keys.Count);
+
+            foreach (var key in keys)
+            {
+                if (!keyBuilder.Contains(key))
+                    keyBuilder.Add(key);
+            }
+
+            keyBuilder.Sort();
+
+            Keys = keyBuilder.MoveToImmutable();
         }
 
         /// <summary>
@@ -41,7 +56,7 @@ public KeyCombination(IEnumerable<InputKey>? keys)
         /// <param name="keys">The keys.</param>
         /// <remarks>This constructor is not optimized. Hot paths are assumed to use <see cref="FromInputState(InputState, Vector2?)"/>.</remarks>
         public KeyCombination(params InputKey[] keys)
-            : this(keys.AsEnumerable())
+            : this((ICollection<InputKey>)keys)
         {
         }
 
@@ -51,7 +66,7 @@ public KeyCombination(params InputKey[] keys)
         /// <param name="keys">A comma-separated (KeyCode in integer) string representation of the keys.</param>
         /// <remarks>This constructor is not optimized. Hot paths are assumed to use <see cref="FromInputState(InputState, Vector2?)"/>.</remarks>
         public KeyCombination(string keys)
-            : this(keys.Split(',', StringSplitOptions.RemoveEmptyEntries).Select(s => (InputKey)int.Parse(s)))
+            : this(keys.Split(',', StringSplitOptions.RemoveEmptyEntries).Select(s => (InputKey)int.Parse(s)).ToArray())
         {
         }
 

osu.Framework/Input/ButtonEventManager.cs

@@ -121,7 +121,16 @@ private void handleButtonUp(InputState state)
         /// <returns>The drawable which handled the event or null if none.</returns>
         protected Drawable? PropagateButtonEvent(IEnumerable<Drawable> drawables, UIEvent e)
         {
-            var handledBy = drawables.FirstOrDefault(target => target.TriggerEvent(e));
+            Drawable? handledBy = null;
+
+            foreach (Drawable target in drawables)
+            {
+                if (target.TriggerEvent(e))
+                {
+                    handledBy = target;
+                    break;
+                }
+            }
 
             if (handledBy != null)
                 Logger.Log($"{e} handled by {handledBy}.", LoggingTarget.Runtime, LogLevel.Debug);