typo, comment

Neo.ConsoleService/CommandToken.cs

@@ -29,7 +29,7 @@ internal abstract class CommandToken
         /// <summary>
         /// Value
         /// </summary>
-        public string Value { get; protected set; }
+        public string Value { get; protected init; }
 
         /// <summary>
         /// Constructor
@@ -152,7 +152,7 @@ public static void Trim(List<CommandToken> args)
 
             // Trim end
 
-            while (args.Count > 0 && args[args.Count - 1].Type == CommandTokenType.Space)
+            while (args.Count > 0 && args[^1].Type == CommandTokenType.Space)
             {
                 args.RemoveAt(args.Count - 1);
             }

Neo.ConsoleService/ConsoleCommandMethod.cs

@@ -52,7 +52,7 @@ internal class ConsoleCommandMethod
         /// </summary>
         /// <param name="instance">Instance</param>
         /// <param name="method">Method</param>
-        /// <param name="verbs">Verbs</param>
+        /// <param name="attribute">Attribute</param>
         public ConsoleCommandMethod(object instance, MethodInfo method, ConsoleCommandAttribute attribute)
         {
             Method = method;

Neo.ConsoleService/ConsoleServiceBase.cs

@@ -35,11 +35,11 @@ public abstract class ConsoleServiceBase
         public bool ReadingPassword { get; set; } = false;
 
         private bool _running;
-        private readonly CancellationTokenSource _shutdownTokenSource = new CancellationTokenSource();
-        private readonly CountdownEvent _shutdownAcknowledged = new CountdownEvent(1);
-        private readonly Dictionary<string, List<ConsoleCommandMethod>> _verbs = new Dictionary<string, List<ConsoleCommandMethod>>();
-        private readonly Dictionary<string, object> _instances = new Dictionary<string, object>();
-        private readonly Dictionary<Type, Func<List<CommandToken>, bool, object>> _handlers = new Dictionary<Type, Func<List<CommandToken>, bool, object>>();
+        private readonly CancellationTokenSource _shutdownTokenSource = new();
+        private readonly CountdownEvent _shutdownAcknowledged = new(1);
+        private readonly Dictionary<string, List<ConsoleCommandMethod>> _verbs = new();
+        private readonly Dictionary<string, object> _instances = new();
+        private readonly Dictionary<Type, Func<List<CommandToken>, bool, object>> _handlers = new();
 
         private bool OnCommand(string commandLine)
         {
@@ -114,7 +114,7 @@ private bool OnCommand(string commandLine)
                 case 1:
                     {
                         var (command, arguments) = availableCommands[0];
-                        object result = command.Method.Invoke(command.Instance, arguments);
+                        var result = command.Method.Invoke(command.Instance, arguments);
                         if (result is Task task) task.Wait();
                         return true;
                     }
@@ -188,10 +188,10 @@ protected void OnHelpCommand(string key)
 
             withHelp.Sort((a, b) =>
             {
-                var cate = a.HelpCategory.CompareTo(b.HelpCategory);
+                var cate = string.Compare(a.HelpCategory, b.HelpCategory, StringComparison.Ordinal);
                 if (cate == 0)
                 {
-                    cate = a.Key.CompareTo(b.Key);
+                    cate = string.Compare(a.Key, b.Key, StringComparison.Ordinal);
                 }
                 return cate;
             });
@@ -234,7 +234,7 @@ protected void OnHelpCommand(string key)
 
                     if (lastKey != command.Key)
                     {
-                        Console.WriteLine($"You can call this command like this:");
+                        Console.WriteLine("You can call this command like this:");
                         lastKey = command.Key;
                     }
 
@@ -247,7 +247,7 @@ protected void OnHelpCommand(string key)
 
                 if (!found)
                 {
-                    throw new ArgumentException($"Command not found.");
+                    throw new ArgumentException("Command not found.");
                 }
             }
         }
@@ -297,8 +297,7 @@ public virtual void OnStop()
         public string ReadUserInput(string prompt, bool password = false)
         {
             const string t = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
-            StringBuilder sb = new StringBuilder();
-            ConsoleKeyInfo key;
+            var sb = new StringBuilder();
 
             if (!string.IsNullOrEmpty(prompt))
             {
@@ -316,21 +315,15 @@ public string ReadUserInput(string prompt, bool password = false)
             }
             else
             {
+                ConsoleKeyInfo key;
                 do
                 {
                     key = Console.ReadKey(true);
 
                     if (t.IndexOf(key.KeyChar) != -1)
                     {
                         sb.Append(key.KeyChar);
-                        if (password)
-                        {
-                            Console.Write('*');
-                        }
-                        else
-                        {
-                            Console.Write(key.KeyChar);
-                        }
+                        Console.Write(password ? '*' : key.KeyChar);
                     }
                     else if (key.Key == ConsoleKey.Backspace && sb.Length > 0)
                     {
@@ -411,38 +404,33 @@ protected ConsoleServiceBase()
         {
             // Register self commands
 
-            RegisterCommandHander<string>((args, canConsumeAll) =>
-            {
-                return CommandToken.ReadString(args, canConsumeAll);
-            });
+            RegisterCommandHandler<string>(CommandToken.ReadString);
 
-            RegisterCommandHander<string[]>((args, canConsumeAll) =>
+            RegisterCommandHandler<string[]>((args, canConsumeAll) =>
             {
                 if (canConsumeAll)
                 {
                     var ret = CommandToken.ToString(args);
                     args.Clear();
-                    return ret.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
-                }
-                else
-                {
-                    return CommandToken.ReadString(args, false).Split(',', ' ');
+                    return ret.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
                 }
+
+                return CommandToken.ReadString(args, false).Split(',', ' ');
             });
 
-            RegisterCommandHander<string, byte>(false, (str) => byte.Parse(str));
-            RegisterCommandHander<string, bool>(false, (str) => str == "1" || str == "yes" || str == "y" || bool.Parse(str));
-            RegisterCommandHander<string, ushort>(false, (str) => ushort.Parse(str));
-            RegisterCommandHander<string, uint>(false, (str) => uint.Parse(str));
-            RegisterCommandHander<string, IPAddress>(false, (str) => IPAddress.Parse(str));
+            RegisterCommandHandler<string, byte>(false, str => byte.Parse(str));
+            RegisterCommandHandler<string, bool>(false, str => str == "1" || str == "yes" || str == "y" || bool.Parse(str));
+            RegisterCommandHandler<string, ushort>(false, str => ushort.Parse(str));
+            RegisterCommandHandler<string, uint>(false, str => uint.Parse(str));
+            RegisterCommandHandler<string, IPAddress>(false, IPAddress.Parse);
         }
 
         /// <summary>
         /// Register command handler
         /// </summary>
         /// <typeparam name="TRet">Return type</typeparam>
         /// <param name="handler">Handler</param>
-        private void RegisterCommandHander<TRet>(Func<List<CommandToken>, bool, object> handler)
+        private void RegisterCommandHandler<TRet>(Func<List<CommandToken>, bool, object> handler)
         {
             _handlers[typeof(TRet)] = handler;
         }
@@ -454,9 +442,9 @@ private void RegisterCommandHander<TRet>(Func<List<CommandToken>, bool, object>
         /// <typeparam name="TRet">Return type</typeparam>
         /// <param name="canConsumeAll">Can consume all</param>
         /// <param name="handler">Handler</param>
-        public void RegisterCommandHander<T, TRet>(bool canConsumeAll, Func<T, object> handler)
+        public void RegisterCommandHandler<T, TRet>(bool canConsumeAll, Func<T, object> handler)
         {
-            _handlers[typeof(TRet)] = (args, cosumeAll) =>
+            _handlers[typeof(TRet)] = (args, _) =>
             {
                 var value = (T)_handlers[typeof(T)](args, canConsumeAll);
                 return handler(value);
@@ -469,11 +457,11 @@ public void RegisterCommandHander<T, TRet>(bool canConsumeAll, Func<T, object> h
         /// <typeparam name="T">Base type</typeparam>
         /// <typeparam name="TRet">Return type</typeparam>
         /// <param name="handler">Handler</param>
-        public void RegisterCommandHander<T, TRet>(Func<T, object> handler)
+        public void RegisterCommandHandler<T, TRet>(Func<T, object> handler)
         {
-            _handlers[typeof(TRet)] = (args, cosumeAll) =>
+            _handlers[typeof(TRet)] = (args, consumeAll) =>
             {
-                var value = (T)_handlers[typeof(T)](args, cosumeAll);
+                var value = (T)_handlers[typeof(T)](args, consumeAll);
                 return handler(value);
             };
         }
@@ -498,7 +486,7 @@ public void RegisterCommand(object instance, string name = null)
 
                     if (!method.GetParameters().All(u => u.ParameterType.IsEnum || _handlers.ContainsKey(u.ParameterType)))
                     {
-                        throw new ArgumentException("Handler not found for the command: " + method.ToString());
+                        throw new ArgumentException("Handler not found for the command: " + method);
                     }
 
                     // Add command
@@ -576,7 +564,7 @@ public void Run(string[] args)
 
         protected string ReadLine()
         {
-            Task<string> readLineTask = Task.Run(() => Console.ReadLine());
+            Task<string> readLineTask = Task.Run(Console.ReadLine);
 
             try
             {
@@ -598,7 +586,10 @@ public virtual void RunConsole()
                 {
                     Console.Title = ServiceName;
                 }
-                catch { }
+                catch
+                {
+                    // ignored
+                }
 
             Console.ForegroundColor = ConsoleColor.DarkGreen;
             Console.SetIn(new StreamReader(Console.OpenStandardInput(), Console.InputEncoding, false, ushort.MaxValue));
@@ -612,7 +603,7 @@ public virtual void RunConsole()
                 }
 
                 Console.ForegroundColor = ConsoleColor.Yellow;
-                string line = ReadLine()?.Trim();
+                var line = ReadLine()?.Trim();
                 if (line == null) break;
                 Console.ForegroundColor = ConsoleColor.White;
 
@@ -623,7 +614,7 @@ public virtual void RunConsole()
                         ConsoleHelper.Error("Command not found");
                     }
                 }
-                catch (TargetInvocationException ex)
+                catch (TargetInvocationException ex) when (ex.InnerException is not null)
                 {
                     ConsoleHelper.Error(ex.InnerException.Message);
                 }

Neo.ConsoleService/ServiceProxy.cs

@@ -14,21 +14,21 @@ namespace Neo.ConsoleService
 {
     internal class ServiceProxy : ServiceBase
     {
-        private readonly ConsoleServiceBase service;
+        private readonly ConsoleServiceBase _service;
 
         public ServiceProxy(ConsoleServiceBase service)
         {
-            this.service = service;
+            this._service = service;
         }
 
         protected override void OnStart(string[] args)
         {
-            service.OnStart(args);
+            _service.OnStart(args);
         }
 
         protected override void OnStop()
         {
-            service.OnStop();
+            _service.OnStop();
         }
     }
 }

neo-cli/CLI/ConsolePercent.cs

@@ -16,7 +16,8 @@ public class ConsolePercent : IDisposable
     {
         #region Variables
 
-        private long _maxValue, _value;
+        private readonly long _maxValue;
+        private long _value;
         private decimal _lastFactor;
         private string _lastPercent;
 
@@ -33,7 +34,7 @@ public class ConsolePercent : IDisposable
         /// </summary>
         public long Value
         {
-            get { return _value; }
+            get => _value;
             set
             {
                 if (value == _value) return;
@@ -48,8 +49,8 @@ public long Value
         /// </summary>
         public long MaxValue
         {
-            get { return _maxValue; }
-            set
+            get => _maxValue;
+            init
             {
                 if (value == _maxValue) return;
 

neo-cli/CLI/Logger.cs

@@ -27,26 +27,31 @@ internal class Logger : Plugin, ILogPlugin
 
         public override string Name => "SystemLog";
         public override string Description => "Prints consensus log and is a built-in plugin which cannot be uninstalled";
-        public override string ConfigFile => Combine(GetDirectoryName(Path), "config.json");
+        public override string ConfigFile => Combine(GetDirectoryName(Path) ?? throw new InvalidOperationException(), "config.json");
         public override string Path => GetType().Assembly.Location;
 
         private static void GetErrorLogs(StringBuilder sb, Exception ex)
         {
-            sb.AppendLine(ex.GetType().ToString());
-            sb.AppendLine(ex.Message);
-            sb.AppendLine(ex.StackTrace);
-            if (ex is AggregateException ex2)
+            while (true)
             {
-                foreach (Exception inner in ex2.InnerExceptions)
+                sb.AppendLine(ex.GetType().ToString());
+                sb.AppendLine(ex.Message);
+                sb.AppendLine(ex.StackTrace);
+                if (ex is AggregateException ex2)
+                {
+                    foreach (var inner in ex2.InnerExceptions)
+                    {
+                        sb.AppendLine();
+                        GetErrorLogs(sb, inner);
+                    }
+                }
+                else if (ex.InnerException != null)
                 {
                     sb.AppendLine();
-                    GetErrorLogs(sb, inner);
+                    ex = ex.InnerException;
+                    continue;
                 }
-            }
-            else if (ex.InnerException != null)
-            {
-                sb.AppendLine();
-                GetErrorLogs(sb, ex.InnerException);
+                break;
             }
         }
 
@@ -78,28 +83,28 @@ void ILogPlugin.Log(string source, LogLevel level, object message)
                         case LogLevel.Fatal: FatalColor.Apply(); break;
                         case LogLevel.Info: InfoColor.Apply(); break;
                         case LogLevel.Warning: WarningColor.Apply(); break;
+                        default:
+                            throw new ArgumentOutOfRangeException(nameof(level), level, null);
                     }
 
                     Console.WriteLine(log);
                     currentColor.Apply();
                 }
 
-                if (!string.IsNullOrEmpty(Settings.Default.Logger.Path))
+                if (string.IsNullOrEmpty(Settings.Default.Logger.Path)) return;
+                var sb = new StringBuilder(source);
+                foreach (var c in GetInvalidFileNameChars())
+                    sb.Replace(c, '-');
+                var path = Combine(Settings.Default.Logger.Path, sb.ToString());
+                Directory.CreateDirectory(path);
+                path = Combine(path, $"{now:yyyy-MM-dd}.log");
+                try
                 {
-                    StringBuilder sb = new StringBuilder(source);
-                    foreach (char c in GetInvalidFileNameChars())
-                        sb.Replace(c, '-');
-                    var path = Combine(Settings.Default.Logger.Path, sb.ToString());
-                    Directory.CreateDirectory(path);
-                    path = Combine(path, $"{now:yyyy-MM-dd}.log");
-                    try
-                    {
-                        File.AppendAllLines(path, new[] { $"[{level}]{log}" });
-                    }
-                    catch (IOException)
-                    {
-                        Console.WriteLine("Error writing the log file: " + path);
-                    }
+                    File.AppendAllLines(path, new[] { $"[{level}]{log}" });
+                }
+                catch (IOException)
+                {
+                    Console.WriteLine("Error writing the log file: " + path);
                 }
             }
         }