1 files changed, 52 insertions, 50 deletions
diff --git a/src/Ryujinx.Common/Logging/Logger.cs b/src/Ryujinx.Common/Logging/Logger.cs
index 25f9c5ee..f03a7fd8 100644
--- a/src/Ryujinx.Common/Logging/Logger.cs
+++ b/src/Ryujinx.Common/Logging/Logger.cs
@@ -10,11 +10,11 @@ namespace Ryujinx.Common.Logging
 {
     public static class Logger
     {
-        private static readonly Stopwatch m_Time;
+        private static readonly Stopwatch _time;
 
-        private static readonly bool[] m_EnabledClasses;
+        private static readonly bool[] _enabledClasses;
 
-        private static readonly List<ILogTarget> m_LogTargets;
+        private static readonly List<ILogTarget> _logTargets;
 
         private static readonly StdErrAdapter _stdErrAdapter;
 
@@ -32,27 +32,27 @@ namespace Ryujinx.Common.Logging
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public void PrintMsg(LogClass logClass, string message)
             {
-                if (m_EnabledClasses[(int)logClass])
+                if (_enabledClasses[(int)logClass])
                 {
-                    Updated?.Invoke(null, new LogEventArgs(Level, m_Time.Elapsed, Thread.CurrentThread.Name, FormatMessage(logClass, "", message)));
+                    Updated?.Invoke(null, new LogEventArgs(Level, _time.Elapsed, Thread.CurrentThread.Name, FormatMessage(logClass, "", message)));
                 }
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public void Print(LogClass logClass, string message, [CallerMemberName] string caller = "")
             {
-                if (m_EnabledClasses[(int)logClass])
+                if (_enabledClasses[(int)logClass])
                 {
-                    Updated?.Invoke(null, new LogEventArgs(Level, m_Time.Elapsed, Thread.CurrentThread.Name, FormatMessage(logClass, caller, message)));
+                    Updated?.Invoke(null, new LogEventArgs(Level, _time.Elapsed, Thread.CurrentThread.Name, FormatMessage(logClass, caller, message)));
                 }
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public void Print(LogClass logClass, string message, object data, [CallerMemberName] string caller = "")
             {
-                if (m_EnabledClasses[(int)logClass])
+                if (_enabledClasses[(int)logClass])
                 {
-                    Updated?.Invoke(null, new LogEventArgs(Level, m_Time.Elapsed, Thread.CurrentThread.Name, FormatMessage(logClass, caller, message), data));
+                    Updated?.Invoke(null, new LogEventArgs(Level, _time.Elapsed, Thread.CurrentThread.Name, FormatMessage(logClass, caller, message), data));
                 }
             }
 
@@ -60,71 +60,71 @@ namespace Ryujinx.Common.Logging
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public void PrintStack(LogClass logClass, string message, [CallerMemberName] string caller = "")
             {
-                if (m_EnabledClasses[(int)logClass])
+                if (_enabledClasses[(int)logClass])
                 {
-                    Updated?.Invoke(null, new LogEventArgs(Level, m_Time.Elapsed, Thread.CurrentThread.Name, FormatMessage(logClass, caller, message), new StackTrace(true)));
+                    Updated?.Invoke(null, new LogEventArgs(Level, _time.Elapsed, Thread.CurrentThread.Name, FormatMessage(logClass, caller, message), new StackTrace(true)));
                 }
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public void PrintStub(LogClass logClass, string message = "", [CallerMemberName] string caller = "")
             {
-                if (m_EnabledClasses[(int)logClass])
+                if (_enabledClasses[(int)logClass])
                 {
-                    Updated?.Invoke(null, new LogEventArgs(Level, m_Time.Elapsed, Thread.CurrentThread.Name, FormatMessage(logClass, caller, "Stubbed. " + message)));
+                    Updated?.Invoke(null, new LogEventArgs(Level, _time.Elapsed, Thread.CurrentThread.Name, FormatMessage(logClass, caller, "Stubbed. " + message)));
                 }
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public void PrintStub(LogClass logClass, object data, [CallerMemberName] string caller = "")
             {
-                if (m_EnabledClasses[(int)logClass])
+                if (_enabledClasses[(int)logClass])
                 {
-                    Updated?.Invoke(null, new LogEventArgs(Level, m_Time.Elapsed, Thread.CurrentThread.Name, FormatMessage(logClass, caller, "Stubbed."), data));
+                    Updated?.Invoke(null, new LogEventArgs(Level, _time.Elapsed, Thread.CurrentThread.Name, FormatMessage(logClass, caller, "Stubbed."), data));
                 }
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public void PrintStub(LogClass logClass, string message, object data, [CallerMemberName] string caller = "")
             {
-                if (m_EnabledClasses[(int)logClass])
+                if (_enabledClasses[(int)logClass])
                 {
-                    Updated?.Invoke(null, new LogEventArgs(Level, m_Time.Elapsed, Thread.CurrentThread.Name, FormatMessage(logClass, caller, "Stubbed. " + message), data));
+                    Updated?.Invoke(null, new LogEventArgs(Level, _time.Elapsed, Thread.CurrentThread.Name, FormatMessage(logClass, caller, "Stubbed. " + message), data));
                 }
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public void PrintRawMsg(string message)
             {
-                Updated?.Invoke(null, new LogEventArgs(Level, m_Time.Elapsed, Thread.CurrentThread.Name, message));
+                Updated?.Invoke(null, new LogEventArgs(Level, _time.Elapsed, Thread.CurrentThread.Name, message));
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            private static string FormatMessage(LogClass Class, string Caller, string Message) => $"{Class} {Caller}: {Message}";
+            private static string FormatMessage(LogClass logClass, string caller, string message) => $"{logClass} {caller}: {message}";
         }
 
-        public static Log? Debug     { get; private set; }
-        public static Log? Info      { get; private set; }
-        public static Log? Warning   { get; private set; }
-        public static Log? Error     { get; private set; }
-        public static Log? Guest     { get; private set; }
+        public static Log? Debug { get; private set; }
+        public static Log? Info { get; private set; }
+        public static Log? Warning { get; private set; }
+        public static Log? Error { get; private set; }
+        public static Log? Guest { get; private set; }
         public static Log? AccessLog { get; private set; }
-        public static Log? Stub      { get; private set; }
-        public static Log? Trace     { get; private set; }
-        public static Log  Notice    { get; } // Always enabled
+        public static Log? Stub { get; private set; }
+        public static Log? Trace { get; private set; }
+        public static Log Notice { get; } // Always enabled
 
         static Logger()
         {
-            m_EnabledClasses = new bool[Enum.GetNames<LogClass>().Length];
+            _enabledClasses = new bool[Enum.GetNames<LogClass>().Length];
 
-            for (int index = 0; index < m_EnabledClasses.Length; index++)
+            for (int index = 0; index < _enabledClasses.Length; index++)
             {
-                m_EnabledClasses[index] = true;
+                _enabledClasses[index] = true;
             }
 
-            m_LogTargets = new List<ILogTarget>();
+            _logTargets = new List<ILogTarget>();
 
-            m_Time = Stopwatch.StartNew();
+            _time = Stopwatch.StartNew();
 
             // Logger should log to console by default
             AddTarget(new AsyncLogTargetWrapper(
@@ -145,12 +145,12 @@ namespace Ryujinx.Common.Logging
 
         public static void RestartTime()
         {
-            m_Time.Restart();
+            _time.Restart();
         }
 
         private static ILogTarget GetTarget(string targetName)
         {
-            foreach (var target in m_LogTargets)
+            foreach (var target in _logTargets)
             {
                 if (target.Name.Equals(targetName))
                 {
@@ -163,7 +163,7 @@ namespace Ryujinx.Common.Logging
 
         public static void AddTarget(ILogTarget target)
         {
-            m_LogTargets.Add(target);
+            _logTargets.Add(target);
 
             Updated += target.Log;
         }
@@ -176,7 +176,7 @@ namespace Ryujinx.Common.Logging
             {
                 Updated -= logTarget.Log;
 
-                m_LogTargets.Remove(logTarget);
+                _logTargets.Remove(logTarget);
 
                 logTarget.Dispose();
             }
@@ -188,18 +188,18 @@ namespace Ryujinx.Common.Logging
 
             _stdErrAdapter.Dispose();
 
-            foreach (var target in m_LogTargets)
+            foreach (var target in _logTargets)
             {
                 target.Dispose();
             }
 
-            m_LogTargets.Clear();
+            _logTargets.Clear();
         }
 
         public static IReadOnlyCollection<LogLevel> GetEnabledLevels()
         {
-            var logs = new Log?[] { Debug, Info, Warning, Error, Guest, AccessLog, Stub, Trace };
-            List<LogLevel> levels = new List<LogLevel>(logs.Length);
+            var logs = new[] { Debug, Info, Warning, Error, Guest, AccessLog, Stub, Trace };
+            List<LogLevel> levels = new(logs.Length);
             foreach (var log in logs)
             {
                 if (log.HasValue)
@@ -215,21 +215,23 @@ namespace Ryujinx.Common.Logging
         {
             switch (logLevel)
             {
-                case LogLevel.Debug     : Debug     = enabled ? new Log(LogLevel.Debug)    : new Log?(); break;
-                case LogLevel.Info      : Info      = enabled ? new Log(LogLevel.Info)     : new Log?(); break;
-                case LogLevel.Warning   : Warning   = enabled ? new Log(LogLevel.Warning)  : new Log?(); break;
-                case LogLevel.Error     : Error     = enabled ? new Log(LogLevel.Error)    : new Log?(); break;
-                case LogLevel.Guest     : Guest     = enabled ? new Log(LogLevel.Guest)    : new Log?(); break;
-                case LogLevel.AccessLog : AccessLog = enabled ? new Log(LogLevel.AccessLog): new Log?(); break;
-                case LogLevel.Stub      : Stub      = enabled ? new Log(LogLevel.Stub)     : new Log?(); break;
-                case LogLevel.Trace     : Trace     = enabled ? new Log(LogLevel.Trace)    : new Log?(); break;
+#pragma warning disable IDE0055 // Disable formatting
+                case LogLevel.Debug     : Debug     = enabled ? new Log(LogLevel.Debug)     : new Log?(); break;
+                case LogLevel.Info      : Info      = enabled ? new Log(LogLevel.Info)      : new Log?(); break;
+                case LogLevel.Warning   : Warning   = enabled ? new Log(LogLevel.Warning)   : new Log?(); break;
+                case LogLevel.Error     : Error     = enabled ? new Log(LogLevel.Error)     : new Log?(); break;
+                case LogLevel.Guest     : Guest     = enabled ? new Log(LogLevel.Guest)     : new Log?(); break;
+                case LogLevel.AccessLog : AccessLog = enabled ? new Log(LogLevel.AccessLog) : new Log?(); break;
+                case LogLevel.Stub      : Stub      = enabled ? new Log(LogLevel.Stub)      : new Log?(); break;
+                case LogLevel.Trace     : Trace     = enabled ? new Log(LogLevel.Trace)     : new Log?(); break;
                 default: throw new ArgumentException("Unknown Log Level");
+#pragma warning restore IDE0055
             }
         }
 
         public static void SetEnable(LogClass logClass, bool enabled)
         {
-            m_EnabledClasses[(int)logClass] = enabled;
+            _enabledClasses[(int)logClass] = enabled;
         }
     }
-}
-\ No newline at end of file
+}