private void ProcessArguments()
        {
            while (Arguments.Count > 0)
            {
                // When we detect the SwitchEscape symbol, we stop processing.
                if (Arguments[0] == SwitchEscape)
                {
                    Arguments.RemoveAt(0);
                    break;
                }
                var cmdOption =
                    Options.FirstOrDefault(
                        option => option.Name == Arguments[0] || option.ShortName == Arguments[0]);
                if (cmdOption == null)
                {
                    throw new SyntaxErrorException($"Unknown switch `{Arguments[0]}'");
                }

                if (cmdOption is ISwitchOption)
                {
                    TrySetValue(cmdOption, cmdOption.EnumValue);
                }
                // A boolean switch, e.g., '-v' can be specified as an unary switch '-v' or as a binary switch '-v [true|false]'
                else if (cmdOption is BoolOption && (Arguments.Count == 1 || IsSwitch(Arguments[1])))
                {
                    TrySetValue(cmdOption, true.ToString());
                }
                else
                {
                    if (Arguments.Count == 1)
                    {
                        throw new SyntaxErrorException($"Switch `{cmdOption.Name}' requires an argument.");
                    }
                    if (IsSwitch(Arguments[1]))
                    {
                        throw new SyntaxErrorException($"Switch '{cmdOption.Name}' requires an argument.");
                    }
                    TrySetValue(cmdOption, Arguments[1]);
                    Arguments.RemoveAt(0);
                }
                Arguments.RemoveAt(0);
                ProcessedOptions.Add(cmdOption);
                if (cmdOption is ICommandOption)
                {
                    break; // Stop option handling when reaching a subcommand switch
                }
            }
        }
        /// <summary>
        ///     Override this method to implement validation of options and arguments after processing.
        /// </summary>
        protected virtual void ValidateArguments()
        {
            if (Usage.IsDefined || HasUnprocessedHelp())
            {
                // Stop validation when '--help' switch is used
                return;
            }

            // Check if all required options have been specified.
            foreach (var option in Options.Where(arg => arg.Required))
            {
                if (ProcessedOptions.Contains(option) == false)
                {
                    throw new SyntaxErrorException($"Required switch `{option.Name}' is missing.");
                }
            }
        }