[Ryujinx.Memory] Address dotnet-format issues (#5386)

* dotnet format style --severity info

Some changes were manually reverted.

* dotnet format analyzers --serverity info

Some changes have been minimally adapted.

* Silence dotnet format IDE0059 warnings

* Address or silence dotnet format IDE1006 warnings

* Address dotnet format CA1816 warnings

* Address or silence dotnet format CA1069 warnings

* Address remaining dotnet format analyzer warnings

* Address review comments

* Address most dotnet format whitespace warnings

* Apply dotnet format whitespace formatting

A few of them have been manually reverted and the corresponding warning was silenced

* Format if-blocks correctly

* Another rebase, another dotnet format run

* Run dotnet format after rebase and remove unused usings

- analyzers
- style
- whitespace

* Add comments to disabled warnings

* Simplify properties and array initialization, Use const when possible, Remove trailing commas

* Revert "Simplify properties and array initialization, Use const when possible, Remove trailing commas"

This reverts commit 9462e4136c0a2100dc28b20cf9542e06790aa67e.

* dotnet format whitespace after rebase

* Address review feedback

* Assign Decommit to ReplacePlaceholder

* Run final dotnet format pass

* Organize imports again

* Add trailing commas

* Add missing newline

src/Ryujinx.Input/Assigner/GamepadButtonAssigner.cs

@@ -10,15 +10,15 @@ namespace Ryujinx.Input.Assigner
     /// </summary>
     public class GamepadButtonAssigner : IButtonAssigner
     {
-        private IGamepad _gamepad;
+        private readonly IGamepad _gamepad;
 
         private GamepadStateSnapshot _currState;
 
         private GamepadStateSnapshot _prevState;
 
-        private JoystickButtonDetector _detector;
+        private readonly JoystickButtonDetector _detector;
 
-        private bool _forStick;
+        private readonly bool _forStick;
 
         public GamepadButtonAssigner(IGamepad gamepad, float triggerThreshold, bool forStick)
         {
@@ -35,7 +35,7 @@ namespace Ryujinx.Input.Assigner
             {
                 _currState = _gamepad.GetStateSnapshot();
                 _prevState = _currState;
-            }    
+            }
         }
 
         public void ReadInput()
@@ -116,7 +116,7 @@ namespace Ryujinx.Input.Assigner
 
         private class JoystickButtonDetector
         {
-            private Dictionary<GamepadButtonInputId, InputSummary> _stats;
+            private readonly Dictionary<GamepadButtonInputId, InputSummary> _stats;
 
             public JoystickButtonDetector()
             {
@@ -135,9 +135,8 @@ namespace Ryujinx.Input.Assigner
 
             public void AddInput(GamepadButtonInputId button, float value)
             {
-                InputSummary inputSummary;
 
-                if (!_stats.TryGetValue(button, out inputSummary))
+                if (!_stats.TryGetValue(button, out InputSummary inputSummary))
                 {
                     inputSummary = new InputSummary();
                     _stats.Add(button, inputSummary);
@@ -148,7 +147,7 @@ namespace Ryujinx.Input.Assigner
 
             public override string ToString()
             {
-                StringWriter writer = new StringWriter();
+                StringWriter writer = new();
 
                 foreach (var kvp in _stats)
                 {

src/Ryujinx.Input/Assigner/IButtonAssigner.cs

@@ -33,4 +33,4 @@ namespace Ryujinx.Input.Assigner
         /// <returns>The pressed button that was read</returns>
         string GetPressedButton();
     }
-}
+}

src/Ryujinx.Input/Assigner/KeyboardKeyAssigner.cs

@@ -5,7 +5,7 @@ namespace Ryujinx.Input.Assigner
     /// </summary>
     public class KeyboardKeyAssigner : IButtonAssigner
     {
-        private IKeyboard _keyboard;
+        private readonly IKeyboard _keyboard;
 
         private KeyboardStateSnapshot _keyboardState;
 
@@ -47,4 +47,4 @@ namespace Ryujinx.Input.Assigner
             return !ShouldCancel() ? keyPressed : "";
         }
     }
-}
+}

src/Ryujinx.Input/GamepadButtonInputId.cs

@@ -52,6 +52,6 @@
         SingleLeftTrigger1,
         SingleRightTrigger1,
 
-        Count
+        Count,
     }
 }

src/Ryujinx.Input/GamepadFeaturesFlag.cs

@@ -23,6 +23,6 @@ namespace Ryujinx.Input
         /// Motion
         /// <remarks>Also named sixaxis</remarks>
         /// </summary>
-        Motion
+        Motion,
     }
 }

src/Ryujinx.Input/HLE/InputManager.cs

@@ -25,7 +25,7 @@ namespace Ryujinx.Input.HLE
         {
             return new NpadManager(KeyboardDriver, GamepadDriver, MouseDriver);
         }
-        
+
         public TouchScreenManager CreateTouchScreenManager()
         {
             if (MouseDriver == null)
@@ -48,6 +48,7 @@ namespace Ryujinx.Input.HLE
 
         public void Dispose()
         {
+            GC.SuppressFinalize(this);
             Dispose(true);
         }
     }

src/Ryujinx.Input/HLE/NpadController.cs

@@ -8,7 +8,6 @@ using System;
 using System.Collections.Concurrent;
 using System.Numerics;
 using System.Runtime.CompilerServices;
-
 using CemuHookClient = Ryujinx.Input.Motion.CemuHook.Client;
 using ConfigControllerType = Ryujinx.Common.Configuration.Hid.ControllerType;
 
@@ -28,29 +27,28 @@ namespace Ryujinx.Input.HLE
             }
         }
 
-        private static readonly HLEButtonMappingEntry[] _hleButtonMapping = new HLEButtonMappingEntry[]
+        private static readonly HLEButtonMappingEntry[] _hleButtonMapping = {
-        {
+            new(GamepadButtonInputId.A, ControllerKeys.A),
-            new HLEButtonMappingEntry(GamepadButtonInputId.A, ControllerKeys.A),
+            new(GamepadButtonInputId.B, ControllerKeys.B),
-            new HLEButtonMappingEntry(GamepadButtonInputId.B, ControllerKeys.B),
+            new(GamepadButtonInputId.X, ControllerKeys.X),
-            new HLEButtonMappingEntry(GamepadButtonInputId.X, ControllerKeys.X),
+            new(GamepadButtonInputId.Y, ControllerKeys.Y),
-            new HLEButtonMappingEntry(GamepadButtonInputId.Y, ControllerKeys.Y),
+            new(GamepadButtonInputId.LeftStick, ControllerKeys.LStick),
-            new HLEButtonMappingEntry(GamepadButtonInputId.LeftStick, ControllerKeys.LStick),
+            new(GamepadButtonInputId.RightStick, ControllerKeys.RStick),
-            new HLEButtonMappingEntry(GamepadButtonInputId.RightStick, ControllerKeys.RStick),
+            new(GamepadButtonInputId.LeftShoulder, ControllerKeys.L),
-            new HLEButtonMappingEntry(GamepadButtonInputId.LeftShoulder, ControllerKeys.L),
+            new(GamepadButtonInputId.RightShoulder, ControllerKeys.R),
-            new HLEButtonMappingEntry(GamepadButtonInputId.RightShoulder, ControllerKeys.R),
+            new(GamepadButtonInputId.LeftTrigger, ControllerKeys.Zl),
-            new HLEButtonMappingEntry(GamepadButtonInputId.LeftTrigger, ControllerKeys.Zl),
+            new(GamepadButtonInputId.RightTrigger, ControllerKeys.Zr),
-            new HLEButtonMappingEntry(GamepadButtonInputId.RightTrigger, ControllerKeys.Zr),
+            new(GamepadButtonInputId.DpadUp, ControllerKeys.DpadUp),
-            new HLEButtonMappingEntry(GamepadButtonInputId.DpadUp, ControllerKeys.DpadUp),
+            new(GamepadButtonInputId.DpadDown, ControllerKeys.DpadDown),
-            new HLEButtonMappingEntry(GamepadButtonInputId.DpadDown, ControllerKeys.DpadDown),
+            new(GamepadButtonInputId.DpadLeft, ControllerKeys.DpadLeft),
-            new HLEButtonMappingEntry(GamepadButtonInputId.DpadLeft, ControllerKeys.DpadLeft),
+            new(GamepadButtonInputId.DpadRight, ControllerKeys.DpadRight),
-            new HLEButtonMappingEntry(GamepadButtonInputId.DpadRight, ControllerKeys.DpadRight),
+            new(GamepadButtonInputId.Minus, ControllerKeys.Minus),
-            new HLEButtonMappingEntry(GamepadButtonInputId.Minus, ControllerKeys.Minus),
+            new(GamepadButtonInputId.Plus, ControllerKeys.Plus),
-            new HLEButtonMappingEntry(GamepadButtonInputId.Plus, ControllerKeys.Plus),
 
-            new HLEButtonMappingEntry(GamepadButtonInputId.SingleLeftTrigger0, ControllerKeys.SlLeft),
+            new(GamepadButtonInputId.SingleLeftTrigger0, ControllerKeys.SlLeft),
-            new HLEButtonMappingEntry(GamepadButtonInputId.SingleRightTrigger0, ControllerKeys.SrLeft),
+            new(GamepadButtonInputId.SingleRightTrigger0, ControllerKeys.SrLeft),
-            new HLEButtonMappingEntry(GamepadButtonInputId.SingleLeftTrigger1, ControllerKeys.SlRight),
+            new(GamepadButtonInputId.SingleLeftTrigger1, ControllerKeys.SlRight),
-            new HLEButtonMappingEntry(GamepadButtonInputId.SingleRightTrigger1, ControllerKeys.SrRight),
+            new(GamepadButtonInputId.SingleRightTrigger1, ControllerKeys.SrRight),
         };
 
         private class HLEKeyboardMappingEntry
@@ -65,150 +63,147 @@ namespace Ryujinx.Input.HLE
             }
         }
 
-        private static readonly HLEKeyboardMappingEntry[] KeyMapping = new HLEKeyboardMappingEntry[]
+        private static readonly HLEKeyboardMappingEntry[] _keyMapping = {
-        {
+            new(Key.A, 0x4),
-            new HLEKeyboardMappingEntry(Key.A, 0x4),
+            new(Key.B, 0x5),
-            new HLEKeyboardMappingEntry(Key.B, 0x5),
+            new(Key.C, 0x6),
-            new HLEKeyboardMappingEntry(Key.C, 0x6),
+            new(Key.D, 0x7),
-            new HLEKeyboardMappingEntry(Key.D, 0x7),
+            new(Key.E, 0x8),
-            new HLEKeyboardMappingEntry(Key.E, 0x8),
+            new(Key.F, 0x9),
-            new HLEKeyboardMappingEntry(Key.F, 0x9),
+            new(Key.G, 0xA),
-            new HLEKeyboardMappingEntry(Key.G, 0xA),
+            new(Key.H, 0xB),
-            new HLEKeyboardMappingEntry(Key.H, 0xB),
+            new(Key.I, 0xC),
-            new HLEKeyboardMappingEntry(Key.I, 0xC),
+            new(Key.J, 0xD),
-            new HLEKeyboardMappingEntry(Key.J, 0xD),
+            new(Key.K, 0xE),
-            new HLEKeyboardMappingEntry(Key.K, 0xE),
+            new(Key.L, 0xF),
-            new HLEKeyboardMappingEntry(Key.L, 0xF),
+            new(Key.M, 0x10),
-            new HLEKeyboardMappingEntry(Key.M, 0x10),
+            new(Key.N, 0x11),
-            new HLEKeyboardMappingEntry(Key.N, 0x11),
+            new(Key.O, 0x12),
-            new HLEKeyboardMappingEntry(Key.O, 0x12),
+            new(Key.P, 0x13),
-            new HLEKeyboardMappingEntry(Key.P, 0x13),
+            new(Key.Q, 0x14),
-            new HLEKeyboardMappingEntry(Key.Q, 0x14),
+            new(Key.R, 0x15),
-            new HLEKeyboardMappingEntry(Key.R, 0x15),
+            new(Key.S, 0x16),
-            new HLEKeyboardMappingEntry(Key.S, 0x16),
+            new(Key.T, 0x17),
-            new HLEKeyboardMappingEntry(Key.T, 0x17),
+            new(Key.U, 0x18),
-            new HLEKeyboardMappingEntry(Key.U, 0x18),
+            new(Key.V, 0x19),
-            new HLEKeyboardMappingEntry(Key.V, 0x19),
+            new(Key.W, 0x1A),
-            new HLEKeyboardMappingEntry(Key.W, 0x1A),
+            new(Key.X, 0x1B),
-            new HLEKeyboardMappingEntry(Key.X, 0x1B),
+            new(Key.Y, 0x1C),
-            new HLEKeyboardMappingEntry(Key.Y, 0x1C),
+            new(Key.Z, 0x1D),
-            new HLEKeyboardMappingEntry(Key.Z, 0x1D),
 
-            new HLEKeyboardMappingEntry(Key.Number1, 0x1E),
+            new(Key.Number1, 0x1E),
-            new HLEKeyboardMappingEntry(Key.Number2, 0x1F),
+            new(Key.Number2, 0x1F),
-            new HLEKeyboardMappingEntry(Key.Number3, 0x20),
+            new(Key.Number3, 0x20),
-            new HLEKeyboardMappingEntry(Key.Number4, 0x21),
+            new(Key.Number4, 0x21),
-            new HLEKeyboardMappingEntry(Key.Number5, 0x22),
+            new(Key.Number5, 0x22),
-            new HLEKeyboardMappingEntry(Key.Number6, 0x23),
+            new(Key.Number6, 0x23),
-            new HLEKeyboardMappingEntry(Key.Number7, 0x24),
+            new(Key.Number7, 0x24),
-            new HLEKeyboardMappingEntry(Key.Number8, 0x25),
+            new(Key.Number8, 0x25),
-            new HLEKeyboardMappingEntry(Key.Number9, 0x26),
+            new(Key.Number9, 0x26),
-            new HLEKeyboardMappingEntry(Key.Number0, 0x27),
+            new(Key.Number0, 0x27),
 
-            new HLEKeyboardMappingEntry(Key.Enter,        0x28),
+            new(Key.Enter,        0x28),
-            new HLEKeyboardMappingEntry(Key.Escape,       0x29),
+            new(Key.Escape,       0x29),
-            new HLEKeyboardMappingEntry(Key.BackSpace,    0x2A),
+            new(Key.BackSpace,    0x2A),
-            new HLEKeyboardMappingEntry(Key.Tab,          0x2B),
+            new(Key.Tab,          0x2B),
-            new HLEKeyboardMappingEntry(Key.Space,        0x2C),
+            new(Key.Space,        0x2C),
-            new HLEKeyboardMappingEntry(Key.Minus,        0x2D),
+            new(Key.Minus,        0x2D),
-            new HLEKeyboardMappingEntry(Key.Plus,         0x2E),
+            new(Key.Plus,         0x2E),
-            new HLEKeyboardMappingEntry(Key.BracketLeft,  0x2F),
+            new(Key.BracketLeft,  0x2F),
-            new HLEKeyboardMappingEntry(Key.BracketRight, 0x30),
+            new(Key.BracketRight, 0x30),
-            new HLEKeyboardMappingEntry(Key.BackSlash,    0x31),
+            new(Key.BackSlash,    0x31),
-            new HLEKeyboardMappingEntry(Key.Tilde,        0x32),
+            new(Key.Tilde,        0x32),
-            new HLEKeyboardMappingEntry(Key.Semicolon,    0x33),
+            new(Key.Semicolon,    0x33),
-            new HLEKeyboardMappingEntry(Key.Quote,        0x34),
+            new(Key.Quote,        0x34),
-            new HLEKeyboardMappingEntry(Key.Grave,        0x35),
+            new(Key.Grave,        0x35),
-            new HLEKeyboardMappingEntry(Key.Comma,        0x36),
+            new(Key.Comma,        0x36),
-            new HLEKeyboardMappingEntry(Key.Period,       0x37),
+            new(Key.Period,       0x37),
-            new HLEKeyboardMappingEntry(Key.Slash,        0x38),
+            new(Key.Slash,        0x38),
-            new HLEKeyboardMappingEntry(Key.CapsLock,     0x39),
+            new(Key.CapsLock,     0x39),
 
-            new HLEKeyboardMappingEntry(Key.F1,  0x3a),
+            new(Key.F1,  0x3a),
-            new HLEKeyboardMappingEntry(Key.F2,  0x3b),
+            new(Key.F2,  0x3b),
-            new HLEKeyboardMappingEntry(Key.F3,  0x3c),
+            new(Key.F3,  0x3c),
-            new HLEKeyboardMappingEntry(Key.F4,  0x3d),
+            new(Key.F4,  0x3d),
-            new HLEKeyboardMappingEntry(Key.F5,  0x3e),
+            new(Key.F5,  0x3e),
-            new HLEKeyboardMappingEntry(Key.F6,  0x3f),
+            new(Key.F6,  0x3f),
-            new HLEKeyboardMappingEntry(Key.F7,  0x40),
+            new(Key.F7,  0x40),
-            new HLEKeyboardMappingEntry(Key.F8,  0x41),
+            new(Key.F8,  0x41),
-            new HLEKeyboardMappingEntry(Key.F9,  0x42),
+            new(Key.F9,  0x42),
-            new HLEKeyboardMappingEntry(Key.F10, 0x43),
+            new(Key.F10, 0x43),
-            new HLEKeyboardMappingEntry(Key.F11, 0x44),
+            new(Key.F11, 0x44),
-            new HLEKeyboardMappingEntry(Key.F12, 0x45),
+            new(Key.F12, 0x45),
 
-            new HLEKeyboardMappingEntry(Key.PrintScreen, 0x46),
+            new(Key.PrintScreen, 0x46),
-            new HLEKeyboardMappingEntry(Key.ScrollLock,  0x47),
+            new(Key.ScrollLock,  0x47),
-            new HLEKeyboardMappingEntry(Key.Pause,       0x48),
+            new(Key.Pause,       0x48),
-            new HLEKeyboardMappingEntry(Key.Insert,      0x49),
+            new(Key.Insert,      0x49),
-            new HLEKeyboardMappingEntry(Key.Home,        0x4A),
+            new(Key.Home,        0x4A),
-            new HLEKeyboardMappingEntry(Key.PageUp,      0x4B),
+            new(Key.PageUp,      0x4B),
-            new HLEKeyboardMappingEntry(Key.Delete,      0x4C),
+            new(Key.Delete,      0x4C),
-            new HLEKeyboardMappingEntry(Key.End,         0x4D),
+            new(Key.End,         0x4D),
-            new HLEKeyboardMappingEntry(Key.PageDown,    0x4E),
+            new(Key.PageDown,    0x4E),
-            new HLEKeyboardMappingEntry(Key.Right,       0x4F),
+            new(Key.Right,       0x4F),
-            new HLEKeyboardMappingEntry(Key.Left,        0x50),
+            new(Key.Left,        0x50),
-            new HLEKeyboardMappingEntry(Key.Down,        0x51),
+            new(Key.Down,        0x51),
-            new HLEKeyboardMappingEntry(Key.Up,          0x52),
+            new(Key.Up,          0x52),
 
-            new HLEKeyboardMappingEntry(Key.NumLock,        0x53),
+            new(Key.NumLock,        0x53),
-            new HLEKeyboardMappingEntry(Key.KeypadDivide,   0x54),
+            new(Key.KeypadDivide,   0x54),
-            new HLEKeyboardMappingEntry(Key.KeypadMultiply, 0x55),
+            new(Key.KeypadMultiply, 0x55),
-            new HLEKeyboardMappingEntry(Key.KeypadSubtract, 0x56),
+            new(Key.KeypadSubtract, 0x56),
-            new HLEKeyboardMappingEntry(Key.KeypadAdd,      0x57),
+            new(Key.KeypadAdd,      0x57),
-            new HLEKeyboardMappingEntry(Key.KeypadEnter,    0x58),
+            new(Key.KeypadEnter,    0x58),
-            new HLEKeyboardMappingEntry(Key.Keypad1,        0x59),
+            new(Key.Keypad1,        0x59),
-            new HLEKeyboardMappingEntry(Key.Keypad2,        0x5A),
+            new(Key.Keypad2,        0x5A),
-            new HLEKeyboardMappingEntry(Key.Keypad3,        0x5B),
+            new(Key.Keypad3,        0x5B),
-            new HLEKeyboardMappingEntry(Key.Keypad4,        0x5C),
+            new(Key.Keypad4,        0x5C),
-            new HLEKeyboardMappingEntry(Key.Keypad5,        0x5D),
+            new(Key.Keypad5,        0x5D),
-            new HLEKeyboardMappingEntry(Key.Keypad6,        0x5E),
+            new(Key.Keypad6,        0x5E),
-            new HLEKeyboardMappingEntry(Key.Keypad7,        0x5F),
+            new(Key.Keypad7,        0x5F),
-            new HLEKeyboardMappingEntry(Key.Keypad8,        0x60),
+            new(Key.Keypad8,        0x60),
-            new HLEKeyboardMappingEntry(Key.Keypad9,        0x61),
+            new(Key.Keypad9,        0x61),
-            new HLEKeyboardMappingEntry(Key.Keypad0,        0x62),
+            new(Key.Keypad0,        0x62),
-            new HLEKeyboardMappingEntry(Key.KeypadDecimal,  0x63),
+            new(Key.KeypadDecimal,  0x63),
 
-            new HLEKeyboardMappingEntry(Key.F13, 0x68),
+            new(Key.F13, 0x68),
-            new HLEKeyboardMappingEntry(Key.F14, 0x69),
+            new(Key.F14, 0x69),
-            new HLEKeyboardMappingEntry(Key.F15, 0x6A),
+            new(Key.F15, 0x6A),
-            new HLEKeyboardMappingEntry(Key.F16, 0x6B),
+            new(Key.F16, 0x6B),
-            new HLEKeyboardMappingEntry(Key.F17, 0x6C),
+            new(Key.F17, 0x6C),
-            new HLEKeyboardMappingEntry(Key.F18, 0x6D),
+            new(Key.F18, 0x6D),
-            new HLEKeyboardMappingEntry(Key.F19, 0x6E),
+            new(Key.F19, 0x6E),
-            new HLEKeyboardMappingEntry(Key.F20, 0x6F),
+            new(Key.F20, 0x6F),
-            new HLEKeyboardMappingEntry(Key.F21, 0x70),
+            new(Key.F21, 0x70),
-            new HLEKeyboardMappingEntry(Key.F22, 0x71),
+            new(Key.F22, 0x71),
-            new HLEKeyboardMappingEntry(Key.F23, 0x72),
+            new(Key.F23, 0x72),
-            new HLEKeyboardMappingEntry(Key.F24, 0x73),
+            new(Key.F24, 0x73),
 
-            new HLEKeyboardMappingEntry(Key.ControlLeft,  0xE0),
+            new(Key.ControlLeft,  0xE0),
-            new HLEKeyboardMappingEntry(Key.ShiftLeft,    0xE1),
+            new(Key.ShiftLeft,    0xE1),
-            new HLEKeyboardMappingEntry(Key.AltLeft,      0xE2),
+            new(Key.AltLeft,      0xE2),
-            new HLEKeyboardMappingEntry(Key.WinLeft,      0xE3),
+            new(Key.WinLeft,      0xE3),
-            new HLEKeyboardMappingEntry(Key.ControlRight, 0xE4),
+            new(Key.ControlRight, 0xE4),
-            new HLEKeyboardMappingEntry(Key.ShiftRight,   0xE5),
+            new(Key.ShiftRight,   0xE5),
-            new HLEKeyboardMappingEntry(Key.AltRight,     0xE6),
+            new(Key.AltRight,     0xE6),
-            new HLEKeyboardMappingEntry(Key.WinRight,     0xE7),
+            new(Key.WinRight,     0xE7),
         };
 
-        private static readonly HLEKeyboardMappingEntry[] KeyModifierMapping = new HLEKeyboardMappingEntry[]
+        private static readonly HLEKeyboardMappingEntry[] _keyModifierMapping = {
-        {
+            new(Key.ControlLeft,  0),
-            new HLEKeyboardMappingEntry(Key.ControlLeft,  0),
+            new(Key.ShiftLeft,    1),
-            new HLEKeyboardMappingEntry(Key.ShiftLeft,    1),
+            new(Key.AltLeft,      2),
-            new HLEKeyboardMappingEntry(Key.AltLeft,      2),
+            new(Key.WinLeft,      3),
-            new HLEKeyboardMappingEntry(Key.WinLeft,      3),
+            new(Key.ControlRight, 4),
-            new HLEKeyboardMappingEntry(Key.ControlRight, 4),
+            new(Key.ShiftRight,   5),
-            new HLEKeyboardMappingEntry(Key.ShiftRight,   5),
+            new(Key.AltRight,     6),
-            new HLEKeyboardMappingEntry(Key.AltRight,     6),
+            new(Key.WinRight,     7),
-            new HLEKeyboardMappingEntry(Key.WinRight,     7),
+            new(Key.CapsLock,     8),
-            new HLEKeyboardMappingEntry(Key.CapsLock,     8),
+            new(Key.ScrollLock,   9),
-            new HLEKeyboardMappingEntry(Key.ScrollLock,   9),
+            new(Key.NumLock,      10),
-            new HLEKeyboardMappingEntry(Key.NumLock,      10),
         };
 
         private bool _isValid;
-        private string _id;
 
         private MotionInput _leftMotionInput;
         private MotionInput _rightMotionInput;
@@ -219,14 +214,14 @@ namespace Ryujinx.Input.HLE
         public IGamepadDriver GamepadDriver { get; private set; }
         public GamepadStateSnapshot State { get; private set; }
 
-        public string Id => _id;
+        public string Id { get; private set; }
 
-        private CemuHookClient _cemuHookClient;
+        private readonly CemuHookClient _cemuHookClient;
 
         public NpadController(CemuHookClient cemuHookClient)
         {
             State = default;
-            _id = null;
+            Id = null;
             _isValid = false;
             _cemuHookClient = cemuHookClient;
         }
@@ -237,8 +232,8 @@ namespace Ryujinx.Input.HLE
 
             _gamepad?.Dispose();
 
-            _id = config.Id;
+            Id = config.Id;
-            _gamepad = GamepadDriver.GetGamepad(_id);
+            _gamepad = GamepadDriver.GetGamepad(Id);
             _isValid = _gamepad != null;
 
             UpdateUserConfiguration(config);
@@ -278,7 +273,7 @@ namespace Ryujinx.Input.HLE
             if (motionConfig.MotionBackend != MotionInputBackendType.CemuHook)
             {
                 _leftMotionInput = new MotionInput();
-             }
+            }
             else
             {
                 _leftMotionInput = null;
@@ -347,7 +342,7 @@ namespace Ryujinx.Input.HLE
 
         public GamepadInput GetHLEInputState()
         {
-            GamepadInput state = new GamepadInput();
+            GamepadInput state = new();
 
             // First update all buttons
             foreach (HLEButtonMappingEntry entry in _hleButtonMapping)
@@ -366,13 +361,13 @@ namespace Ryujinx.Input.HLE
                 state.LStick = new JoystickPosition
                 {
                     Dx = ClampAxis(leftAxisX),
-                    Dy = ClampAxis(leftAxisY)
+                    Dy = ClampAxis(leftAxisY),
                 };
 
                 state.RStick = new JoystickPosition
                 {
                     Dx = ClampAxis(rightAxisX),
-                    Dy = ClampAxis(rightAxisY)
+                    Dy = ClampAxis(rightAxisY),
                 };
             }
             else if (_config is StandardControllerInputConfig controllerConfig)
@@ -391,16 +386,16 @@ namespace Ryujinx.Input.HLE
         private static JoystickPosition ApplyDeadzone(float x, float y, float deadzone)
         {
             float magnitudeClamped = Math.Min(MathF.Sqrt(x * x + y * y), 1f);
-            
+
             if (magnitudeClamped <= deadzone)
             {
-                return new JoystickPosition() {Dx = 0, Dy = 0};
+                return new JoystickPosition { Dx = 0, Dy = 0 };
             }
-            
+
-            return new JoystickPosition()
+            return new JoystickPosition
             {
                 Dx = ClampAxis((x / magnitudeClamped) * ((magnitudeClamped - deadzone) / (1 - deadzone))),
-                Dy = ClampAxis((y / magnitudeClamped) * ((magnitudeClamped - deadzone) / (1 - deadzone)))
+                Dy = ClampAxis((y / magnitudeClamped) * ((magnitudeClamped - deadzone) / (1 - deadzone))),
             };
         }
 
@@ -428,7 +423,7 @@ namespace Ryujinx.Input.HLE
             return new JoystickPosition
             {
                 Dx = (int)point.X,
-                Dy = (int)point.Y
+                Dy = (int)point.Y,
             };
         }
 
@@ -476,12 +471,12 @@ namespace Ryujinx.Input.HLE
                 rotation = new Vector3();
             }
 
-            return new SixAxisInput()
+            return new SixAxisInput
             {
                 Accelerometer = accelerometer,
-                Gyroscope     = gyroscope,
+                Gyroscope = gyroscope,
-                Rotation      = rotation,
+                Rotation = rotation,
-                Orientation   = orientationForHLE
+                Orientation = orientationForHLE,
             };
         }
 
@@ -502,20 +497,20 @@ namespace Ryujinx.Input.HLE
             {
                 KeyboardStateSnapshot keyboardState = keyboard.GetKeyboardStateSnapshot();
 
-                KeyboardInput hidKeyboard = new KeyboardInput
+                KeyboardInput hidKeyboard = new()
                 {
                     Modifier = 0,
-                    Keys = new ulong[0x4]
+                    Keys = new ulong[0x4],
                 };
 
-                foreach (HLEKeyboardMappingEntry entry in KeyMapping)
+                foreach (HLEKeyboardMappingEntry entry in _keyMapping)
                 {
                     ulong value = keyboardState.IsPressed(entry.TargetKey) ? 1UL : 0UL;
 
                     hidKeyboard.Keys[entry.Target / 0x40] |= (value << (entry.Target % 0x40));
                 }
 
-                foreach (HLEKeyboardMappingEntry entry in KeyModifierMapping)
+                foreach (HLEKeyboardMappingEntry entry in _keyModifierMapping)
                 {
                     int value = keyboardState.IsPressed(entry.TargetKey) ? 1 : 0;
 
@@ -539,6 +534,7 @@ namespace Ryujinx.Input.HLE
 
         public void Dispose()
         {
+            GC.SuppressFinalize(this);
             Dispose(true);
         }
 

src/Ryujinx.Input/HLE/NpadManager.cs

@@ -7,13 +7,15 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using CemuHookClient = Ryujinx.Input.Motion.CemuHook.Client;
+using ControllerType = Ryujinx.Common.Configuration.Hid.ControllerType;
+using PlayerIndex = Ryujinx.HLE.HOS.Services.Hid.PlayerIndex;
 using Switch = Ryujinx.HLE.Switch;
 
 namespace Ryujinx.Input.HLE
 {
     public class NpadManager : IDisposable
     {
-        private CemuHookClient _cemuHookClient;
+        private readonly CemuHookClient _cemuHookClient;
 
         private readonly object _lock = new();
 
@@ -21,7 +23,7 @@ namespace Ryujinx.Input.HLE
 
         private const int MaxControllers = 9;
 
-        private NpadController[] _controllers;
+        private readonly NpadController[] _controllers;
 
         private readonly IGamepadDriver _keyboardDriver;
         private readonly IGamepadDriver _gamepadDriver;
@@ -51,7 +53,7 @@ namespace Ryujinx.Input.HLE
         {
             lock (_lock)
             {
-                List<InputConfig> validInputs = new List<InputConfig>();
+                List<InputConfig> validInputs = new();
                 foreach (var inputConfigEntry in _inputConfig)
                 {
                     if (_controllers[(int)inputConfigEntry.PlayerIndex] != null)
@@ -96,10 +98,8 @@ namespace Ryujinx.Input.HLE
             {
                 return controller.UpdateDriverConfiguration(targetDriver, config);
             }
-            else
+
-            {
+            return controller.GamepadDriver != null;
-                return controller.GamepadDriver != null;
-            }
         }
 
         public void ReloadConfiguration(List<InputConfig> inputConfig, bool enableKeyboard, bool enableMouse)
@@ -112,11 +112,11 @@ namespace Ryujinx.Input.HLE
                     _controllers[i] = null;
                 }
 
-                List<InputConfig> validInputs = new List<InputConfig>();
+                List<InputConfig> validInputs = new();
 
                 foreach (InputConfig inputConfigEntry in inputConfig)
                 {
-                    NpadController controller = new NpadController(_cemuHookClient);
+                    NpadController controller = new(_cemuHookClient);
 
                     bool isValid = DriverConfigurationUpdate(ref controller, inputConfigEntry);
 
@@ -131,9 +131,9 @@ namespace Ryujinx.Input.HLE
                     }
                 }
 
-                _inputConfig    = inputConfig;
+                _inputConfig = inputConfig;
                 _enableKeyboard = enableKeyboard;
-                _enableMouse    = enableMouse;
+                _enableMouse = enableMouse;
 
                 _device.Hid.RefreshInputConfig(validInputs);
             }
@@ -167,8 +167,8 @@ namespace Ryujinx.Input.HLE
         {
             lock (_lock)
             {
-                List<GamepadInput> hleInputStates = new List<GamepadInput>();
+                List<GamepadInput> hleInputStates = new();
-                List<SixAxisInput> hleMotionStates = new List<SixAxisInput>(NpadDevices.MaxControllers);
+                List<SixAxisInput> hleMotionStates = new(NpadDevices.MaxControllers);
 
                 KeyboardInput? hleKeyboardInput = null;
 
@@ -178,7 +178,7 @@ namespace Ryujinx.Input.HLE
                     (SixAxisInput, SixAxisInput) motionState = default;
 
                     NpadController controller = _controllers[(int)inputConfig.PlayerIndex];
-                    Ryujinx.HLE.HOS.Services.Hid.PlayerIndex playerIndex = (Ryujinx.HLE.HOS.Services.Hid.PlayerIndex)inputConfig.PlayerIndex;
+                    PlayerIndex playerIndex = (PlayerIndex)inputConfig.PlayerIndex;
 
                     bool isJoyconPair = false;
 
@@ -195,7 +195,7 @@ namespace Ryujinx.Input.HLE
 
                         inputState.Buttons |= _device.Hid.UpdateStickButtons(inputState.LStick, inputState.RStick);
 
-                        isJoyconPair = inputConfig.ControllerType == Common.Configuration.Hid.ControllerType.JoyconPair;
+                        isJoyconPair = inputConfig.ControllerType == ControllerType.JoyconPair;
 
                         var altMotionState = isJoyconPair ? controller.GetHLEMotionState(true) : default;
 
@@ -284,7 +284,7 @@ namespace Ryujinx.Input.HLE
         {
             lock (_lock)
             {
-                return _inputConfig.Find(x => x.PlayerIndex == (Ryujinx.Common.Configuration.Hid.PlayerIndex)index);
+                return _inputConfig.Find(x => x.PlayerIndex == (Common.Configuration.Hid.PlayerIndex)index);
             }
         }
 
@@ -314,6 +314,7 @@ namespace Ryujinx.Input.HLE
 
         public void Dispose()
         {
+            GC.SuppressFinalize(this);
             Dispose(true);
         }
     }

src/Ryujinx.Input/HLE/TouchScreenManager.cs

@@ -31,7 +31,7 @@ namespace Ryujinx.Input.HLE
                     MouseStateSnapshot snapshot = IMouse.GetMouseStateSnapshot(_mouse);
                     var touchPosition = IMouse.GetScreenPosition(snapshot.Position, _mouse.ClientSize, aspectRatio);
 
-                    TouchPoint currentPoint = new TouchPoint
+                    TouchPoint currentPoint = new()
                     {
                         Attribute = TouchAttribute.End,
 
@@ -41,7 +41,7 @@ namespace Ryujinx.Input.HLE
                         // Placeholder values till more data is acquired
                         DiameterX = 10,
                         DiameterY = 10,
-                        Angle = 90
+                        Angle = 90,
                     };
 
                     _device.Hid.Touchscreen.Update(currentPoint);
@@ -71,7 +71,7 @@ namespace Ryujinx.Input.HLE
                     attribute = TouchAttribute.End;
                 }
 
-                TouchPoint currentPoint = new TouchPoint
+                TouchPoint currentPoint = new()
                 {
                     Attribute = attribute,
 
@@ -81,7 +81,7 @@ namespace Ryujinx.Input.HLE
                     // Placeholder values till more data is acquired
                     DiameterX = 10,
                     DiameterY = 10,
-                    Angle = 90
+                    Angle = 90,
                 };
 
                 _device.Hid.Touchscreen.Update(currentPoint);
@@ -94,6 +94,9 @@ namespace Ryujinx.Input.HLE
             return false;
         }
 
-        public void Dispose() { }
+        public void Dispose()
+        {
+            GC.SuppressFinalize(this);
+        }
     }
-}
+}

src/Ryujinx.Input/IMouse.cs

@@ -8,7 +8,9 @@ namespace Ryujinx.Input
     /// </summary>
     public interface IMouse : IGamepad
     {
+#pragma warning disable IDE0051 // Remove unused private member
         private const int SwitchPanelWidth = 1280;
+#pragma warning restore IDE0051
         private const int SwitchPanelHeight = 720;
 
         /// <summary>
@@ -101,4 +103,4 @@ namespace Ryujinx.Input
             return new Vector2();
         }
     }
-}
+}

src/Ryujinx.Input/Key.cs

@@ -137,6 +137,6 @@
         BackSlash,
         Unbound,
 
-        Count
+        Count,
     }
-}
+}

src/Ryujinx.Input/KeyboardStateSnapshot.cs

@@ -7,7 +7,7 @@ namespace Ryujinx.Input
     /// </summary>
     public class KeyboardStateSnapshot
     {
-        private bool[] _keysState;
+        private readonly bool[] _keysState;
 
         /// <summary>
         /// Create a new <see cref="KeyboardStateSnapshot"/>.

src/Ryujinx.Input/Motion/CemuHook/Client.cs

@@ -19,7 +19,7 @@ namespace Ryujinx.Input.Motion.CemuHook
 {
     public class Client : IDisposable
     {
-        public const uint   Magic   = 0x43555344; // DSUC
+        public const uint Magic = 0x43555344; // DSUC
         public const ushort Version = 1001;
 
         private bool _active;
@@ -29,15 +29,15 @@ namespace Ryujinx.Input.Motion.CemuHook
         private readonly Dictionary<int, UdpClient> _clients;
 
         private readonly bool[] _clientErrorStatus = new bool[Enum.GetValues<PlayerIndex>().Length];
-        private readonly long[] _clientRetryTimer  = new long[Enum.GetValues<PlayerIndex>().Length];
+        private readonly long[] _clientRetryTimer = new long[Enum.GetValues<PlayerIndex>().Length];
-        private NpadManager _npadManager;
+        private readonly NpadManager _npadManager;
 
         public Client(NpadManager npadManager)
         {
             _npadManager = npadManager;
-            _hosts       = new Dictionary<int, IPEndPoint>();
+            _hosts = new Dictionary<int, IPEndPoint>();
-            _motionData  = new Dictionary<int, Dictionary<int, MotionInput>>();
+            _motionData = new Dictionary<int, Dictionary<int, MotionInput>>();
-            _clients     = new Dictionary<int, UdpClient>();
+            _clients = new Dictionary<int, UdpClient>();
 
             CloseClients();
         }
@@ -84,7 +84,7 @@ namespace Ryujinx.Input.Motion.CemuHook
 
                 try
                 {
-                    IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse(host), port);
+                    IPEndPoint endPoint = new(IPAddress.Parse(host), port);
 
                     client = new UdpClient(host, port);
 
@@ -141,9 +141,9 @@ namespace Ryujinx.Input.Motion.CemuHook
         {
             lock (_motionData)
             {
-                if (_motionData.ContainsKey(player))
+                if (_motionData.TryGetValue(player, out Dictionary<int, MotionInput> value))
                 {
-                    if (_motionData[player].TryGetValue(slot, out input))
+                    if (value.TryGetValue(slot, out input))
                     {
                         return true;
                     }
@@ -164,26 +164,26 @@ namespace Ryujinx.Input.Motion.CemuHook
 
         private void Send(byte[] data, int clientId)
         {
-            if (_clients.TryGetValue(clientId, out UdpClient _client))
+            if (_clients.TryGetValue(clientId, out UdpClient client))
             {
-                if (_client != null && _client.Client != null && _client.Client.Connected)
+                if (client != null && client.Client != null && client.Client.Connected)
                 {
                     try
                     {
-                        _client?.Send(data, data.Length);
+                        client?.Send(data, data.Length);
                     }
                     catch (SocketException socketException)
                     {
                         if (!_clientErrorStatus[clientId])
                         {
-                            Logger.Warning?.PrintMsg(LogClass.Hid, $"Unable to send data request to motion source at {_client.Client.RemoteEndPoint}. Error: {socketException.ErrorCode}");
+                            Logger.Warning?.PrintMsg(LogClass.Hid, $"Unable to send data request to motion source at {client.Client.RemoteEndPoint}. Error: {socketException.ErrorCode}");
                         }
 
                         _clientErrorStatus[clientId] = true;
 
                         RemoveClient(clientId);
 
-                        _client?.Dispose();
+                        client?.Dispose();
 
                         SetRetryTimer(clientId);
                     }
@@ -193,7 +193,7 @@ namespace Ryujinx.Input.Motion.CemuHook
 
                         RemoveClient(clientId);
 
-                        _client?.Dispose();
+                        client?.Dispose();
 
                         SetRetryTimer(clientId);
                     }
@@ -203,13 +203,13 @@ namespace Ryujinx.Input.Motion.CemuHook
 
         private byte[] Receive(int clientId, int timeout = 0)
         {
-            if (_hosts.TryGetValue(clientId, out IPEndPoint endPoint) && _clients.TryGetValue(clientId, out UdpClient _client))
+            if (_hosts.TryGetValue(clientId, out IPEndPoint endPoint) && _clients.TryGetValue(clientId, out UdpClient client))
             {
-                if (_client != null && _client.Client != null && _client.Client.Connected)
+                if (client != null && client.Client != null && client.Client.Connected)
                 {
-                    _client.Client.ReceiveTimeout = timeout;
+                    client.Client.ReceiveTimeout = timeout;
 
-                    var result = _client?.Receive(ref endPoint);
+                    var result = client?.Receive(ref endPoint);
 
                     if (result.Length > 0)
                     {
@@ -242,9 +242,9 @@ namespace Ryujinx.Input.Motion.CemuHook
 
         public void ReceiveLoop(int clientId)
         {
-            if (_hosts.TryGetValue(clientId, out IPEndPoint endPoint) && _clients.TryGetValue(clientId, out UdpClient _client))
+            if (_hosts.TryGetValue(clientId, out IPEndPoint endPoint) && _clients.TryGetValue(clientId, out UdpClient client))
             {
-                if (_client != null && _client.Client != null && _client.Client.Connected)
+                if (client != null && client.Client != null && client.Client.Connected)
                 {
                     try
                     {
@@ -271,7 +271,7 @@ namespace Ryujinx.Input.Motion.CemuHook
 
                         RemoveClient(clientId);
 
-                        _client?.Dispose();
+                        client?.Dispose();
 
                         SetRetryTimer(clientId);
                     }
@@ -281,7 +281,7 @@ namespace Ryujinx.Input.Motion.CemuHook
 
                         RemoveClient(clientId);
 
-                        _client?.Dispose();
+                        client?.Dispose();
 
                         SetRetryTimer(clientId);
                     }
@@ -297,8 +297,8 @@ namespace Ryujinx.Input.Motion.CemuHook
 
             data = data.AsSpan()[16..].ToArray();
 
-            using MemoryStream stream = new MemoryStream(data);
+            using MemoryStream stream = new(data);
-            using BinaryReader reader = new BinaryReader(stream);
+            using BinaryReader reader = new(stream);
 
             switch (type)
             {
@@ -310,18 +310,18 @@ namespace Ryujinx.Input.Motion.CemuHook
                 case MessageType.Data:
                     ControllerDataResponse inputData = reader.ReadStruct<ControllerDataResponse>();
 
-                    Vector3 accelerometer = new Vector3()
+                    Vector3 accelerometer = new()
                     {
                         X = -inputData.AccelerometerX,
                         Y = inputData.AccelerometerZ,
-                        Z = -inputData.AccelerometerY
+                        Z = -inputData.AccelerometerY,
                     };
 
-                    Vector3 gyroscrope = new Vector3()
+                    Vector3 gyroscrope = new()
                     {
                         X = inputData.GyroscopePitch,
                         Y = inputData.GyroscopeRoll,
-                        Z = -inputData.GyroscopeYaw
+                        Z = -inputData.GyroscopeYaw,
                     };
 
                     ulong timestamp = inputData.MotionTimestamp;
@@ -346,7 +346,7 @@ namespace Ryujinx.Input.Motion.CemuHook
                                 }
                                 else
                                 {
-                                    MotionInput input = new MotionInput();
+                                    MotionInput input = new();
 
                                     input.Update(accelerometer, gyroscrope, timestamp, cemuHookConfig.Sensitivity, (float)cemuHookConfig.GyroDeadzone);
 
@@ -355,11 +355,11 @@ namespace Ryujinx.Input.Motion.CemuHook
                             }
                             else
                             {
-                                MotionInput input = new MotionInput();
+                                MotionInput input = new();
 
                                 input.Update(accelerometer, gyroscrope, timestamp, cemuHookConfig.Sensitivity, (float)cemuHookConfig.GyroDeadzone);
 
-                                _motionData.Add(clientId, new Dictionary<int, MotionInput>() { { slot, input } });
+                                _motionData.Add(clientId, new Dictionary<int, MotionInput> { { slot, input } });
                             }
                         }
                         else
@@ -380,38 +380,37 @@ namespace Ryujinx.Input.Motion.CemuHook
 
             Header header = GenerateHeader(clientId);
 
-            using (MemoryStream stream = MemoryStreamManager.Shared.GetStream())
+            using MemoryStream stream = MemoryStreamManager.Shared.GetStream();
-            using (BinaryWriter writer = new BinaryWriter(stream))
+            using BinaryWriter writer = new(stream);
+
+            writer.WriteStruct(header);
+
+            ControllerInfoRequest request = new()
             {
-                writer.WriteStruct(header);
+                Type = MessageType.Info,
+                PortsCount = 4,
+            };
 
-                ControllerInfoRequest request = new ControllerInfoRequest()
+            request.PortIndices[0] = (byte)slot;
-                {
-                    Type       = MessageType.Info,
-                    PortsCount = 4
-                };
 
-                request.PortIndices[0] = (byte)slot;
+            writer.WriteStruct(request);
 
-                writer.WriteStruct(request);
+            header.Length = (ushort)(stream.Length - 16);
 
-                header.Length = (ushort)(stream.Length - 16);
+            writer.Seek(6, SeekOrigin.Begin);
+            writer.Write(header.Length);
 
-                writer.Seek(6, SeekOrigin.Begin);
+            Crc32.Hash(stream.ToArray(), header.Crc32.AsSpan());
-                writer.Write(header.Length);
 
-                Crc32.Hash(stream.ToArray(), header.Crc32.AsSpan());
+            writer.Seek(8, SeekOrigin.Begin);
+            writer.Write(header.Crc32.AsSpan());
 
-                writer.Seek(8, SeekOrigin.Begin);
+            byte[] data = stream.ToArray();
-                writer.Write(header.Crc32.AsSpan());
 
-                byte[] data = stream.ToArray();
+            Send(data, clientId);
-
-                Send(data, clientId);
-            }
         }
 
-        public unsafe void RequestData(int clientId, int slot)
+        public void RequestData(int clientId, int slot)
         {
             if (!_active)
             {
@@ -420,44 +419,43 @@ namespace Ryujinx.Input.Motion.CemuHook
 
             Header header = GenerateHeader(clientId);
 
-            using (MemoryStream stream = MemoryStreamManager.Shared.GetStream())
+            using MemoryStream stream = MemoryStreamManager.Shared.GetStream();
-            using (BinaryWriter writer = new BinaryWriter(stream))
+            using BinaryWriter writer = new(stream);
+
+            writer.WriteStruct(header);
+
+            ControllerDataRequest request = new()
             {
-                writer.WriteStruct(header);
+                Type = MessageType.Data,
+                Slot = (byte)slot,
+                SubscriberType = SubscriberType.Slot,
+            };
 
-                ControllerDataRequest request = new ControllerDataRequest()
+            writer.WriteStruct(request);
-                {
-                    Type           = MessageType.Data,
-                    Slot           = (byte)slot,
-                    SubscriberType = SubscriberType.Slot
-                };
 
-                writer.WriteStruct(request);
+            header.Length = (ushort)(stream.Length - 16);
 
-                header.Length = (ushort)(stream.Length - 16);
+            writer.Seek(6, SeekOrigin.Begin);
+            writer.Write(header.Length);
 
-                writer.Seek(6, SeekOrigin.Begin);
+            Crc32.Hash(stream.ToArray(), header.Crc32.AsSpan());
-                writer.Write(header.Length);
 
-                Crc32.Hash(stream.ToArray(), header.Crc32.AsSpan());
+            writer.Seek(8, SeekOrigin.Begin);
+            writer.Write(header.Crc32.AsSpan());
 
-                writer.Seek(8, SeekOrigin.Begin);
+            byte[] data = stream.ToArray();
-                writer.Write(header.Crc32.AsSpan());
 
-                byte[] data = stream.ToArray();
+            Send(data, clientId);
-
-                Send(data, clientId);
-            }
         }
 
-        private Header GenerateHeader(int clientId)
+        private static Header GenerateHeader(int clientId)
         {
-            Header header = new Header()
+            Header header = new()
             {
-                Id          = (uint)clientId,
+                Id = (uint)clientId,
                 MagicString = Magic,
-                Version     = Version,
+                Version = Version,
-                Length      = 0
+                Length = 0,
             };
 
             return header;
@@ -465,9 +463,10 @@ namespace Ryujinx.Input.Motion.CemuHook
 
         public void Dispose()
         {
+            GC.SuppressFinalize(this);
             _active = false;
 
             CloseClients();
         }
     }
-}
+}

src/Ryujinx.Input/Motion/CemuHook/Protocol/ControllerData.cs

@@ -16,15 +16,15 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
     public struct ControllerDataResponse
     {
         public SharedResponse Shared;
-        public byte           Connected;
+        public byte Connected;
-        public uint           PacketId;
+        public uint PacketId;
-        public byte           ExtraButtons;
+        public byte ExtraButtons;
-        public byte           MainButtons;
+        public byte MainButtons;
-        public ushort         PSExtraInput;
+        public ushort PSExtraInput;
-        public ushort         LeftStickXY;
+        public ushort LeftStickXY;
-        public ushort         RightStickXY;
+        public ushort RightStickXY;
-        public uint           DPadAnalog;
+        public uint DPadAnalog;
-        public ulong          MainButtonsAnalog;
+        public ulong MainButtonsAnalog;
 
         public Array6<byte> Touch1;
         public Array6<byte> Touch2;
@@ -42,6 +42,6 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
     {
         All,
         Slot,
-        Mac
+        Mac,
     }
-}
+}

src/Ryujinx.Input/Motion/CemuHook/Protocol/ControllerInfo.cs

@@ -7,7 +7,7 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
     public struct ControllerInfoResponse
     {
         public SharedResponse Shared;
-        private byte _zero;
+        private readonly byte _zero;
     }
 
     [StructLayout(LayoutKind.Sequential, Pack = 1)]
@@ -17,4 +17,4 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
         public int PortsCount;
         public Array4<byte> PortIndices;
     }
-}
+}

src/Ryujinx.Input/Motion/CemuHook/Protocol/Header.cs

@@ -12,4 +12,4 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
         public Array4<byte> Crc32;
         public uint Id;
     }
-}
+}

src/Ryujinx.Input/Motion/CemuHook/Protocol/MessageType.cs

@@ -4,6 +4,6 @@
     {
         Protocol = 0x100000,
         Info,
-        Data
+        Data,
     }
-}
+}

src/Ryujinx.Input/Motion/CemuHook/Protocol/SharedResponse.cs

@@ -6,11 +6,11 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
     [StructLayout(LayoutKind.Sequential, Pack = 1)]
     public struct SharedResponse
     {
-        public MessageType     Type;
+        public MessageType Type;
-        public byte            Slot;
+        public byte Slot;
-        public SlotState       State;
+        public SlotState State;
         public DeviceModelType ModelType;
-        public ConnectionType  ConnectionType;
+        public ConnectionType ConnectionType;
 
         public Array6<byte> MacAddress;
         public BatteryStatus BatteryStatus;
@@ -20,21 +20,21 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
     {
         Disconnected,
         Reserved,
-        Connected
+        Connected,
     }
 
     public enum DeviceModelType : byte
     {
         None,
         PartialGyro,
-        FullGyro
+        FullGyro,
     }
 
     public enum ConnectionType : byte
     {
         None,
         USB,
-        Bluetooth
+        Bluetooth,
     }
 
     public enum BatteryStatus : byte
@@ -46,6 +46,6 @@ namespace Ryujinx.Input.Motion.CemuHook.Protocol
         High,
         Full,
         Charging,
-        Charged
+        Charged,
     }
-}
+}

src/Ryujinx.Input/Motion/MotionInput.cs

@@ -6,19 +6,19 @@ namespace Ryujinx.Input
 {
     public class MotionInput
     {
-        public ulong   TimeStamp     { get; set; }
+        public ulong TimeStamp { get; set; }
         public Vector3 Accelerometer { get; set; }
-        public Vector3 Gyroscrope    { get; set; }
+        public Vector3 Gyroscrope { get; set; }
-        public Vector3 Rotation      { get; set; }
+        public Vector3 Rotation { get; set; }
 
         private readonly MotionSensorFilter _filter;
 
         public MotionInput()
         {
-            TimeStamp     = 0;
+            TimeStamp = 0;
             Accelerometer = new Vector3();
-            Gyroscrope    = new Vector3();
+            Gyroscrope = new Vector3();
-            Rotation      = new Vector3();
+            Rotation = new Vector3();
 
             // TODO: RE the correct filter.
             _filter = new MotionSensorFilter(0f);
@@ -62,4 +62,4 @@ namespace Ryujinx.Input
             return degree * (MathF.PI / 180);
         }
     }
-}
+}

src/Ryujinx.Input/Motion/MotionSensorFilter.cs

@@ -106,19 +106,19 @@ namespace Ryujinx.Input.Motion
             float q1 = Quaternion.W;
 
             // Estimated direction of gravity.
-            Vector3 gravity = new Vector3()
+            Vector3 gravity = new()
             {
                 X = 2f * (q2 * q4 - q1 * q3),
                 Y = 2f * (q1 * q2 + q3 * q4),
-                Z = q1 * q1 - q2 * q2 - q3 * q3 + q4 * q4
+                Z = q1 * q1 - q2 * q2 - q3 * q3 + q4 * q4,
             };
 
             // Error is cross product between estimated direction and measured direction of gravity.
-            Vector3 error = new Vector3()
+            Vector3 error = new()
             {
                 X = accel.Y * gravity.Z - accel.Z * gravity.Y,
                 Y = accel.Z * gravity.X - accel.X * gravity.Z,
-                Z = accel.X * gravity.Y - accel.Y * gravity.X
+                Z = accel.X * gravity.Y - accel.Y * gravity.X,
             };
 
             if (Ki > 0f)
@@ -134,7 +134,7 @@ namespace Ryujinx.Input.Motion
             gyro += (Kp * error) + (Ki * _intergralError);
 
             // Integrate rate of change of quaternion.
-            Vector3 delta = new Vector3(q2, q3, q4);
+            Vector3 delta = new(q2, q3, q4);
 
             q1 += (-q2 * gyro.X - q3 * gyro.Y - q4 * gyro.Z) * (SampleRateCoefficient * SamplePeriod);
             q2 += (q1 * gyro.X + delta.Y * gyro.Z - delta.Z * gyro.Y) * (SampleRateCoefficient * SamplePeriod);
@@ -142,7 +142,7 @@ namespace Ryujinx.Input.Motion
             q4 += (q1 * gyro.Z + delta.X * gyro.Y - delta.Y * gyro.X) * (SampleRateCoefficient * SamplePeriod);
 
             // Normalise quaternion.
-            Quaternion quaternion = new Quaternion(q2, q3, q4, q1);
+            Quaternion quaternion = new(q2, q3, q4, q1);
 
             norm = 1f / quaternion.Length();
 
@@ -159,4 +159,4 @@ namespace Ryujinx.Input.Motion
             Quaternion = Quaternion.Identity;
         }
     }
-}
+}

src/Ryujinx.Input/MotionInputId.cs

@@ -20,6 +20,6 @@
         /// Gyroscope.
         /// </summary>
         /// <remarks>Values are in degrees</remarks>
-        Gyroscope
+        Gyroscope,
     }
 }

src/Ryujinx.Input/MouseButton.cs

@@ -11,6 +11,6 @@ namespace Ryujinx.Input
         Button7,
         Button8,
         Button9,
-        Count
+        Count,
     }
-}
+}

src/Ryujinx.Input/MouseStateSnapshot.cs

@@ -8,7 +8,7 @@ namespace Ryujinx.Input
     /// </summary>
     public class MouseStateSnapshot
     {
-        private bool[] _buttonState;
+        private readonly bool[] _buttonState;
 
         /// <summary>
         /// The position of the mouse cursor
@@ -31,7 +31,7 @@ namespace Ryujinx.Input
             _buttonState = buttonState;
 
             Position = position;
-            Scroll   = scroll;
+            Scroll = scroll;
         }
 
         /// <summary>
@@ -42,4 +42,4 @@ namespace Ryujinx.Input
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool IsPressed(MouseButton button) => _buttonState[(int)button];
     }
-}
+}

src/Ryujinx.Input/StickInputId.cs

@@ -9,6 +9,6 @@
         Left,
         Right,
 
-        Count
+        Count,
     }
 }

src/Ryujinx.Memory/AddressSpaceManager.cs

@@ -136,7 +136,7 @@ namespace Ryujinx.Memory
                 {
                     size = Math.Min(data.Length, PageSize - (int)(va & PageMask));
 
-                    data.Slice(0, size).CopyTo(GetHostSpanContiguous(va, size));
+                    data[..size].CopyTo(GetHostSpanContiguous(va, size));
 
                     offset += size;
                 }
@@ -215,7 +215,7 @@ namespace Ryujinx.Memory
 
         /// <inheritdoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private int GetPagesCount(ulong va, uint size, out ulong startVa)
+        private static int GetPagesCount(ulong va, uint size, out ulong startVa)
         {
             // WARNING: Always check if ulong does not overflow during the operations.
             startVa = va & ~(ulong)PageMask;
@@ -224,7 +224,7 @@ namespace Ryujinx.Memory
             return (int)(vaSpan / PageSize);
         }
 
-        private void ThrowMemoryNotContiguous() => throw new MemoryNotContiguousException();
+        private static void ThrowMemoryNotContiguous() => throw new MemoryNotContiguousException();
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private bool IsContiguousAndMapped(ulong va, int size) => IsContiguous(va, size) && IsMapped(va);
@@ -361,7 +361,7 @@ namespace Ryujinx.Memory
             {
                 size = Math.Min(data.Length, PageSize - (int)(va & PageMask));
 
-                GetHostSpanContiguous(va, size).CopyTo(data.Slice(0, size));
+                GetHostSpanContiguous(va, size).CopyTo(data[..size]);
 
                 offset += size;
             }

src/Ryujinx.Memory/MemoryAllocationFlags.cs

@@ -47,6 +47,6 @@ namespace Ryujinx.Memory
         /// Indicates that the memory will be used to store JIT generated code.
         /// On some platforms, this requires special flags to be passed that will allow the memory to be executable.
         /// </summary>
-        Jit = 1 << 5
+        Jit = 1 << 5,
     }
 }

src/Ryujinx.Memory/MemoryBlock.cs

@@ -364,9 +364,9 @@ namespace Ryujinx.Memory
         /// <param name="pointer">Native pointer</param>
         /// <param name="offset">Offset to add</param>
         /// <returns>Native pointer with the added offset</returns>
-        private IntPtr PtrAddr(IntPtr pointer, ulong offset)
+        private static IntPtr PtrAddr(IntPtr pointer, ulong offset)
         {
-            return (IntPtr)(pointer.ToInt64() + (long)offset);
+            return new IntPtr(pointer.ToInt64() + (long)offset);
         }
 
         /// <summary>
@@ -439,4 +439,4 @@ namespace Ryujinx.Memory
 
         private static void ThrowInvalidMemoryRegionException() => throw new InvalidMemoryRegionException();
     }
-}
+}

src/Ryujinx.Memory/MemoryManagement.cs

@@ -203,4 +203,4 @@ namespace Ryujinx.Memory
             }
         }
     }
-}
+}

src/Ryujinx.Memory/MemoryManagementUnix.cs

@@ -50,7 +50,7 @@ namespace Ryujinx.Memory
                 }
             }
 
-            IntPtr ptr = mmap(IntPtr.Zero, size, prot, flags, -1, 0);
+            IntPtr ptr = Mmap(IntPtr.Zero, size, prot, flags, -1, 0);
 
             if (ptr == MAP_FAILED)
             {
@@ -115,7 +115,7 @@ namespace Ryujinx.Memory
                 MemoryPermission.ReadAndExecute => MmapProts.PROT_READ | MmapProts.PROT_EXEC,
                 MemoryPermission.ReadWriteExecute => MmapProts.PROT_READ | MmapProts.PROT_WRITE | MmapProts.PROT_EXEC,
                 MemoryPermission.Execute => MmapProts.PROT_EXEC,
-                _ => throw new MemoryProtectionException(permission)
+                _ => throw new MemoryProtectionException(permission),
             };
         }
 
@@ -185,12 +185,12 @@ namespace Ryujinx.Memory
 
         public static void DestroySharedMemory(IntPtr handle)
         {
-            close((int)handle);
+            close(handle.ToInt32());
         }
 
         public static IntPtr MapSharedMemory(IntPtr handle, ulong size)
         {
-            return mmap(IntPtr.Zero, size, MmapProts.PROT_READ | MmapProts.PROT_WRITE, MmapFlags.MAP_SHARED, (int)handle, 0);
+            return Mmap(IntPtr.Zero, size, MmapProts.PROT_READ | MmapProts.PROT_WRITE, MmapFlags.MAP_SHARED, handle.ToInt32(), 0);
         }
 
         public static void UnmapSharedMemory(IntPtr address, ulong size)
@@ -200,12 +200,12 @@ namespace Ryujinx.Memory
 
         public static void MapView(IntPtr sharedMemory, ulong srcOffset, IntPtr location, ulong size)
         {
-            mmap(location, size, MmapProts.PROT_READ | MmapProts.PROT_WRITE, MmapFlags.MAP_FIXED | MmapFlags.MAP_SHARED, (int)sharedMemory, (long)srcOffset);
+            Mmap(location, size, MmapProts.PROT_READ | MmapProts.PROT_WRITE, MmapFlags.MAP_FIXED | MmapFlags.MAP_SHARED, sharedMemory.ToInt32(), (long)srcOffset);
         }
 
         public static void UnmapView(IntPtr location, ulong size)
         {
-            mmap(location, size, MmapProts.PROT_NONE, MmapFlags.MAP_FIXED | MmapFlags.MAP_PRIVATE | MmapFlags.MAP_ANONYMOUS | MmapFlags.MAP_NORESERVE, -1, 0);
+            Mmap(location, size, MmapProts.PROT_NONE, MmapFlags.MAP_FIXED | MmapFlags.MAP_PRIVATE | MmapFlags.MAP_ANONYMOUS | MmapFlags.MAP_NORESERVE, -1, 0);
         }
     }
-}
+}

src/Ryujinx.Memory/MemoryManagementWindows.cs

@@ -148,4 +148,4 @@ namespace Ryujinx.Memory
             }
         }
     }
-}
+}

src/Ryujinx.Memory/MemoryManagerUnixHelper.cs

@@ -14,7 +14,7 @@ namespace Ryujinx.Memory
             PROT_NONE = 0,
             PROT_READ = 1,
             PROT_WRITE = 2,
-            PROT_EXEC = 4
+            PROT_EXEC = 4,
         }
 
         [Flags]
@@ -26,7 +26,7 @@ namespace Ryujinx.Memory
             MAP_NORESERVE = 8,
             MAP_FIXED = 16,
             MAP_UNLOCKED = 32,
-            MAP_JIT_DARWIN = 0x800
+            MAP_JIT_DARWIN = 0x800,
         }
 
         [Flags]
@@ -164,9 +164,9 @@ namespace Ryujinx.Memory
             return result;
         }
 
-        public static IntPtr mmap(IntPtr address, ulong length, MmapProts prot, MmapFlags flags, int fd, long offset)
+        public static IntPtr Mmap(IntPtr address, ulong length, MmapProts prot, MmapFlags flags, int fd, long offset)
         {
             return Internal_mmap(address, length, prot, MmapFlagsToSystemFlags(flags), fd, offset);
         }
     }
-}
+}

src/Ryujinx.Memory/MemoryMapFlags.cs

@@ -18,6 +18,6 @@ namespace Ryujinx.Memory
         /// and allocate its own private storage for the mapping.
         /// This allows some mappings that would otherwise fail due to host platform restrictions to succeed.
         /// </summary>
-        Private = 1 << 0
+        Private = 1 << 0,
     }
 }

src/Ryujinx.Memory/MemoryNotContiguousException.cs

@@ -16,4 +16,4 @@ namespace Ryujinx.Memory
         {
         }
     }
-}
+}

src/Ryujinx.Memory/MemoryPermission.cs

@@ -46,6 +46,6 @@ namespace Ryujinx.Memory
         /// <summary>
         /// Indicates an invalid protection.
         /// </summary>
-        Invalid = 255
+        Invalid = 255,
     }
 }

src/Ryujinx.Memory/Range/HostMemoryRange.cs

@@ -5,12 +5,12 @@ namespace Ryujinx.Memory.Range
     /// <summary>
     /// Range of memory composed of an address and size.
     /// </summary>
-    public struct HostMemoryRange : IEquatable<HostMemoryRange>
+    public readonly struct HostMemoryRange : IEquatable<HostMemoryRange>
     {
         /// <summary>
         /// An empty memory range, with a null address and zero size.
         /// </summary>
-        public static HostMemoryRange Empty => new HostMemoryRange(0, 0);
+        public static HostMemoryRange Empty => new(0, 0);
 
         /// <summary>
         /// Start address of the range.
@@ -67,5 +67,15 @@ namespace Ryujinx.Memory.Range
         {
             return HashCode.Combine(Address, Size);
         }
+
+        public static bool operator ==(HostMemoryRange left, HostMemoryRange right)
+        {
+            return left.Equals(right);
+        }
+
+        public static bool operator !=(HostMemoryRange left, HostMemoryRange right)
+        {
+            return !(left == right);
+        }
     }
 }

src/Ryujinx.Memory/Range/IRange.cs

@@ -28,4 +28,4 @@ namespace Ryujinx.Memory.Range
         /// <returns>True if overlapping, false otherwise</returns>
         bool OverlapsWith(ulong address, ulong size);
     }
-}
+}

src/Ryujinx.Memory/Range/MemoryRange.cs

@@ -8,7 +8,7 @@
         /// <summary>
         /// An empty memory range, with a null address and zero size.
         /// </summary>
-        public static MemoryRange Empty => new MemoryRange(0UL, 0);
+        public static MemoryRange Empty => new(0UL, 0);
 
         /// <summary>
         /// Start address of the range.

src/Ryujinx.Memory/Range/MultiRange.cs

@@ -310,7 +310,7 @@ namespace Ryujinx.Memory.Range
                 return _singleRange.GetHashCode();
             }
 
-            HashCode hash = new HashCode();
+            HashCode hash = new();
 
             foreach (MemoryRange range in _ranges)
             {
@@ -328,5 +328,15 @@ namespace Ryujinx.Memory.Range
         {
             return HasSingleRange ? _singleRange.ToString() : string.Join(", ", _ranges);
         }
+
+        public static bool operator ==(MultiRange left, MultiRange right)
+        {
+            return left.Equals(right);
+        }
+
+        public static bool operator !=(MultiRange left, MultiRange right)
+        {
+            return !(left == right);
+        }
     }
 }

src/Ryujinx.Memory/Range/RangeList.cs

@@ -238,7 +238,7 @@ namespace Ryujinx.Memory.Range
 
             if (index < 0)
             {
-                return default(T);
+                return default;
             }
 
             return _items[index].Value;
@@ -398,7 +398,7 @@ namespace Ryujinx.Memory.Range
         /// <returns>List index of the item, or complement index of nearest item with lower value on the list</returns>
         private int BinarySearch(ulong address)
         {
-            int left  = 0;
+            int left = 0;
             int right = Count - 1;
 
             while (left <= right)
@@ -435,7 +435,7 @@ namespace Ryujinx.Memory.Range
         /// <returns>List index of the item, or complement index of nearest item with lower value on the list</returns>
         private int BinarySearch(ulong address, ulong endAddress)
         {
-            int left  = 0;
+            int left = 0;
             int right = Count - 1;
 
             while (left <= right)
@@ -480,4 +480,4 @@ namespace Ryujinx.Memory.Range
             }
         }
     }
-}
+}

src/Ryujinx.Memory/Tracking/MemoryTracking.cs

@@ -21,7 +21,7 @@ namespace Ryujinx.Memory.Tracking
         /// This lock must be obtained when traversing or updating the region-handle hierarchy.
         /// It is not required when reading dirty flags.
         /// </summary>
-        internal object TrackingLock = new object();
+        internal object TrackingLock = new();
 
         /// <summary>
         /// Create a new tracking structure for the given "physical" memory block,
@@ -114,7 +114,7 @@ namespace Ryujinx.Memory.Tracking
         /// <returns>A list of virtual regions within the given range</returns>
         internal List<VirtualRegion> GetVirtualRegionsForHandle(ulong va, ulong size)
         {
-            List<VirtualRegion> result = new List<VirtualRegion>();
+            List<VirtualRegion> result = new();
             _virtualRegions.GetOrAddRegions(result, va, size, (va, size) => new VirtualRegion(this, va, size));
 
             return result;
@@ -172,7 +172,7 @@ namespace Ryujinx.Memory.Tracking
             lock (TrackingLock)
             {
                 bool mapped = _memoryManager.IsRangeMapped(address, size);
-                RegionHandle handle = new RegionHandle(this, paAddress, paSize, address, size, id, mapped);
+                RegionHandle handle = new(this, paAddress, paSize, address, size, id, mapped);
 
                 return handle;
             }
@@ -194,7 +194,7 @@ namespace Ryujinx.Memory.Tracking
             lock (TrackingLock)
             {
                 bool mapped = _memoryManager.IsRangeMapped(address, size);
-                RegionHandle handle = new RegionHandle(this, paAddress, paSize, address, size, bitmap, bit, id, mapped);
+                RegionHandle handle = new(this, paAddress, paSize, address, size, bitmap, bit, id, mapped);
 
                 return handle;
             }

src/Ryujinx.Memory/Tracking/MultiRegionHandle.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Threading;
@@ -21,11 +22,11 @@ namespace Ryujinx.Memory.Tracking
         private readonly ulong Granularity;
         private readonly ulong Size;
 
-        private ConcurrentBitmap _dirtyBitmap;
+        private readonly ConcurrentBitmap _dirtyBitmap;
 
         private int _sequenceNumber;
-        private BitMap _sequenceNumberBitmap;
+        private readonly BitMap _sequenceNumberBitmap;
-        private BitMap _dirtyCheckedBitmap;
+        private readonly BitMap _dirtyCheckedBitmap;
         private int _uncheckedHandles;
 
         public bool Dirty { get; private set; } = true;
@@ -54,7 +55,7 @@ namespace Ryujinx.Memory.Tracking
                 // It is assumed that the provided handles do not overlap, in order, are on page boundaries,
                 // and don't extend past the requested range.
 
-                foreach (RegionHandle handle in handles)
+                foreach (RegionHandle handle in handles.Cast<RegionHandle>())
                 {
                     int startIndex = (int)((handle.RealAddress - address) / granularity);
 
@@ -406,6 +407,8 @@ namespace Ryujinx.Memory.Tracking
 
         public void Dispose()
         {
+            GC.SuppressFinalize(this);
+
             foreach (var handle in _handles)
             {
                 handle.Dispose();

src/Ryujinx.Memory/Tracking/RegionHandle.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Reflection.Metadata;
 using System.Threading;
 
 namespace Ryujinx.Memory.Tracking
@@ -50,7 +49,7 @@ namespace Ryujinx.Memory.Tracking
 
         internal IMultiRegionHandle Parent { get; set; }
 
-        private event Action _onDirty;
+        private event Action OnDirty;
 
         private readonly object _preActionLock = new();
         private RegionSignal _preAction; // Action to perform before a read or write. This will block the memory access.
@@ -269,7 +268,7 @@ namespace Ryujinx.Memory.Tracking
                 Dirty = true;
                 if (!oldDirty)
                 {
-                    _onDirty?.Invoke();
+                    OnDirty?.Invoke();
                 }
                 Parent?.SignalWrite();
             }
@@ -311,7 +310,10 @@ namespace Ryujinx.Memory.Tracking
         /// <param name="consecutiveCheck">True if this reprotect is the result of consecutive dirty checks</param>
         public void Reprotect(bool asDirty, bool consecutiveCheck = false)
         {
-            if (_volatile) return;
+            if (_volatile)
+            {
+                return;
+            }
 
             Dirty = asDirty;
 
@@ -403,7 +405,7 @@ namespace Ryujinx.Memory.Tracking
         /// <param name="action">Action to call on dirty</param>
         public void RegisterDirtyEvent(Action action)
         {
-            _onDirty += action;
+            OnDirty += action;
         }
 
         /// <summary>
@@ -461,6 +463,8 @@ namespace Ryujinx.Memory.Tracking
         {
             ObjectDisposedException.ThrowIf(_disposed, this);
 
+            GC.SuppressFinalize(this);
+
             _disposed = true;
 
             lock (_tracking.TrackingLock)

src/Ryujinx.Memory/Tracking/SmartMultiRegionHandle.cs

@@ -17,7 +17,7 @@ namespace Ryujinx.Memory.Tracking
         private readonly ulong _address;
         private readonly ulong _granularity;
         private readonly ulong _size;
-        private MemoryTracking _tracking;
+        private readonly MemoryTracking _tracking;
         private readonly int _id;
 
         public bool Dirty { get; private set; } = true;
@@ -271,6 +271,8 @@ namespace Ryujinx.Memory.Tracking
 
         public void Dispose()
         {
+            GC.SuppressFinalize(this);
+
             foreach (var handle in _handles)
             {
                 handle?.Dispose();

src/Ryujinx.Memory/Tracking/VirtualRegion.cs

@@ -8,7 +8,7 @@ namespace Ryujinx.Memory.Tracking
     /// </summary>
     class VirtualRegion : AbstractRegion
     {
-        public List<RegionHandle> Handles = new List<RegionHandle>();
+        public List<RegionHandle> Handles = new();
 
         private readonly MemoryTracking _tracking;
         private MemoryPermission _lastPermission;
@@ -86,7 +86,10 @@ namespace Ryujinx.Memory.Tracking
             foreach (var handle in Handles)
             {
                 result &= handle.RequiredPermission;
-                if (result == 0) return result;
+                if (result == 0)
+                {
+                    return result;
+                }
             }
             return result;
         }
@@ -128,7 +131,7 @@ namespace Ryujinx.Memory.Tracking
 
         public override INonOverlappingRange Split(ulong splitAddress)
         {
-            VirtualRegion newRegion = new VirtualRegion(_tracking, splitAddress, EndAddress - splitAddress, _lastPermission);
+            VirtualRegion newRegion = new(_tracking, splitAddress, EndAddress - splitAddress, _lastPermission);
             Size = splitAddress - Address;
 
             // The new region inherits all of our parents.

src/Ryujinx.Memory/WindowsShared/MappingTree.cs

@@ -84,4 +84,4 @@ namespace Ryujinx.Memory.WindowsShared
             }
         }
     }
-}
+}

src/Ryujinx.Memory/WindowsShared/PlaceholderManager.cs

@@ -31,9 +31,11 @@ namespace Ryujinx.Memory.WindowsShared
 
             _partialUnmapStatePtr = PartialUnmapState.GlobalState;
 
-            _partialUnmapTrimThread = new Thread(TrimThreadLocalMapLoop);
+            _partialUnmapTrimThread = new Thread(TrimThreadLocalMapLoop)
-            _partialUnmapTrimThread.Name = "CPU.PartialUnmapTrimThread";
+            {
-            _partialUnmapTrimThread.IsBackground = true;
+                Name = "CPU.PartialUnmapTrimThread",
+                IsBackground = true,
+            };
             _partialUnmapTrimThread.Start();
         }
 
@@ -704,8 +706,6 @@ namespace Ryujinx.Memory.WindowsShared
                 count = _protections.GetNodes(address, endAddress, ref overlaps);
             }
 
-            ulong startAddress = address;
-
             for (int index = 0; index < count; index++)
             {
                 var protection = overlaps[index];
@@ -733,4 +733,4 @@ namespace Ryujinx.Memory.WindowsShared
             }
         }
     }
-}
+}

src/Ryujinx.Memory/WindowsShared/WindowsApi.cs

@@ -7,8 +7,8 @@ namespace Ryujinx.Memory.WindowsShared
     [SupportedOSPlatform("windows")]
     static partial class WindowsApi
     {
-        public static readonly IntPtr InvalidHandleValue = new IntPtr(-1);
+        public static readonly IntPtr InvalidHandleValue = new(-1);
-        public static readonly IntPtr CurrentProcessHandle = new IntPtr(-1);
+        public static readonly IntPtr CurrentProcessHandle = new(-1);
 
         [LibraryImport("kernel32.dll", SetLastError = true)]
         public static partial IntPtr VirtualAlloc(
@@ -96,8 +96,8 @@ namespace Ryujinx.Memory.WindowsShared
                 MemoryPermission.ReadAndExecute => MemoryProtection.ExecuteRead,
                 MemoryPermission.ReadWriteExecute => MemoryProtection.ExecuteReadWrite,
                 MemoryPermission.Execute => MemoryProtection.Execute,
-                _ => throw new MemoryProtectionException(permission)
+                _ => throw new MemoryProtectionException(permission),
             };
         }
     }
-}
+}

src/Ryujinx.Memory/WindowsShared/WindowsApiException.cs

@@ -23,4 +23,4 @@ namespace Ryujinx.Memory.WindowsShared
             return $"{functionName} returned error code 0x{WindowsApi.GetLastError():X}.";
         }
     }
-}
+}

src/Ryujinx.Memory/WindowsShared/WindowsFlags.cs

@@ -10,14 +10,14 @@ namespace Ryujinx.Memory.WindowsShared
         Commit = 0x1000,
         Reserve = 0x2000,
         Decommit = 0x4000,
-        ReplacePlaceholder = 0x4000,
+        ReplacePlaceholder = Decommit,
         Release = 0x8000,
         ReservePlaceholder = 0x40000,
         Reset = 0x80000,
         Physical = 0x400000,
         TopDown = 0x100000,
         WriteWatch = 0x200000,
-        LargePages = 0x20000000
+        LargePages = 0x20000000,
     }
 
     [Flags]
@@ -33,7 +33,7 @@ namespace Ryujinx.Memory.WindowsShared
         ExecuteWriteCopy = 0x80,
         GuardModifierflag = 0x100,
         NoCacheModifierflag = 0x200,
-        WriteCombineModifierflag = 0x400
+        WriteCombineModifierflag = 0x400,
     }
 
     [Flags]
@@ -47,6 +47,6 @@ namespace Ryujinx.Memory.WindowsShared
         SectionCommit = 0x8000000,
         SectionImage = 0x1000000,
         SectionNoCache = 0x10000000,
-        SectionReserve = 0x4000000
+        SectionReserve = 0x4000000,
     }
 }