public List <Command> ParseCommands(List <string> lines, long base_line)
        {
            List <Command> commands = new List <Command>(), cur_group_cmds = ObjectPool <List <Command> > .Instance.GetObject();

            GroupCommand current_group_command = null;

            foreach (var line in lines)
            {
                base_line++;

                var data_arr = line.Split(',');

                var is_sub_cmd = data_arr.First().StartsWith("  ") || data_arr.First().StartsWith("__");

                foreach (var cmd in CommandParserIntance.Parse(data_arr))
                {
                    cmd.RelativeLine = base_line;

                    if (is_sub_cmd)
                    {
                        //如果是子命令的话就要添加到当前Group
                        if (current_group_command != null)
                        {
                            current_group_command.AddSubCommand(cmd);
                        }
                    }
                    else
                    {
                        var prev_group = current_group_command;
                        current_group_command = cmd as GroupCommand;

                        if (current_group_command != prev_group)
                        {
                            prev_group?.UpdateSubCommand();
                        }

                        commands.Add(cmd);
                    }
                }
            }

            if (current_group_command is GroupCommand loop)
            {
                loop.UpdateSubCommand();
            }

            ObjectPool <List <Command> > .Instance.PutObject(cur_group_cmds);

            return(commands);
        }
        public IEnumerable <Command> ParallelParseCommands(List <string> lines, long base_line)
        {
            ConcurrentBag <(long index, Command[] cmds, bool is_sub)> result_list = new ConcurrentBag <(long index, Command[] cmds, bool is_sub)>();

            Parallel.For(0, lines.Count, parallel_options, i =>
            {
                var file_line   = i + base_line;
                var line        = lines[i];
                var data_arr    = line.Split(',');
                var is_sub_cmds = data_arr.First().StartsWith("  ") || data_arr.First().StartsWith("__");

                var temp_list = CommandParserIntance.Parse(data_arr).ToArray();

                foreach (var c in temp_list)
                {
                    c.RelativeLine = file_line;
                }

                result_list.Add((file_line, temp_list, is_sub_cmds));
            });

            var result   = result_list.SelectMany(p => p.cmds.Select(cmd => (p.index, cmd, p.is_sub))).OrderBy(z => z.index);
            var sub_cmds = result.Where(x => x.is_sub);
            var groups   = result.Where(x => x.cmd is GroupCommand && !x.is_sub).Select(x => x.cmd).OfType <GroupCommand>();
            var fin_list = result.Except(sub_cmds.Where(sub_cmd =>
            {
                var r = groups.LastOrDefault(z => z.RelativeLine < sub_cmd.index);

                r?.AddSubCommand(sub_cmd.cmd);

                //return true and this sub_command will be removed (from main commands)
                return(true);
            })).Select(p => p.cmd).ToList();

            foreach (var group in groups)
            {
                group.UpdateSubCommand();
            }

            return(fin_list);
        }