public CommandLineHelper(ArgumentCommand command, List <ArgumentOption> options, ProcessDelegate usage, ProcessDelegate emptyArguments, bool acceptEmptyArguments /*, bool isInSpecificOrder*/)
        {
            Command = command;
            if (options == null)
            {
                options = new List <ArgumentOption>();
            }
            Options        = options;
            Usage          = usage;
            EmptyArguments = emptyArguments;
//			IsInSpecificOrder = isInSpecificOrder;
            AcceptEmptyArguments = acceptEmptyArguments;
        }
        public void Process(string[] args)
        {
            // If there are no args, try to call EmptyArguments
            if (args.Length == 0)
            {
                if (!AcceptEmptyArguments)
                {
                    throw new ArgumentException("You must enter some argument! Enter -? for usage.");
                }
                if (EmptyArguments == null)
                {
                    throw new ArgumentException("The EmptyArguments method must be set!");
                }

                EmptyArguments();
                return;
            }

            // Show usage options, if Usage delegate is defined
            if (Usage != null)
            {
                foreach (var arg in args)
                {
                    if (arg == "-?" || arg == "/?" || arg.ToLower() == "-h" || arg.ToLower() == "--help")
                    {
                        Usage();
                        return;
                    }
                }
            }

            // Process options and commands
            IArgument currentArgument = null;
            var       expectedArgs    = 0;
            var       commandList     = new List <IArgument>();
            var       optionList      = new Dictionary <string, IArgument>();
            var       errorMessageStr = new StringBuilder();

            foreach (var arg in args)
            {
                // Verify if it is a option and remove prefixes from arg
                string argClean = CleanOptionArgument(arg);
                bool   isOption = argClean != null;
                // If are not expecting some internal argument, begin processing options
                if (expectedArgs == 0)
                {
                    // Process the option
                    if (isOption)
                    {
                        // Search for the option in the Options list
                        IArgument currentOption = GetCurrentOption(argClean);
                        if (currentOption != null)
                        {
                            // If the option has already been added, generates an exception
                            if (optionList.Count > 0 && optionList[currentOption.Name] != null)
                            {
                                throw new ArgumentException(string.Format("Could not process option '{0}' argument '{1}' twice! Enter -? for usage.",
                                                                          currentOption.Name, arg));
                            }
                            // Add the option to the option list
                            optionList[currentOption.Name] = currentOption;
                            currentArgument = currentOption;
                            expectedArgs    = currentOption.InternalArguments.Count;
                            continue;
                        }
                        // If option not found, then we got a wrong argument
                        throw new ArgumentException(string.Format("Option '{0}' doesn't exist! Enter '-?' for usage.", arg));
                    }
                    // Now process the Command, if exists
                    if (Command != null)
                    {
                        // If the command doesn't allow multiple executions, generates an exception
                        if (commandList.Count > 0 && !Command.AllowMultipleExecutions)
                        {
                            throw new ArgumentException(string.Format("Could not process command '{0}' argument '{1}' twice! Enter '-?' for usage.",
                                                                      Command.Name, arg));
                        }
                        // Create a copy of internal arguments into a new list
                        var internalArguments = Command.InternalArguments;
                        List <ArgumentInternal> newInternalArguments = GetNewInternalArguments(internalArguments);
                        // Set the first internal argument to arg
                        newInternalArguments[0].Value = arg;
                        // Create a new command and add to the commandList (to be executed after the options)
                        var currentCommand = new ArgumentCommand(Command.Name, Command.Description, Command.AllowMultipleExecutions,
                                                                 newInternalArguments, Command.Process);
                        commandList.Add(currentCommand);
                        // Set the currentArgument to the new command and set the expectedArgs
                        currentArgument = currentCommand;
                        expectedArgs    = newInternalArguments.Count - 1;
                        continue;
                    }
                    // If it gets here, there is something wrong
                    throw new ArgumentException(string.Format("Unespected argument '{0}'! Enter '-?' for usage.", arg));
                }
                // Now we are expecting some internal argument, so set it's values to arg
                if (expectedArgs > 0 && currentArgument != null)
                {
                    // If the argument is a option, there is something wrong
                    if (isOption)
                    {
                        throw new ArgumentException(string.Format("Argument '{0}' invalid to option '{1}'! Enter '-?' for usage.",
                                                                  arg, currentArgument.Name));
                    }

                    currentArgument.InternalArguments[currentArgument.InternalArguments.Count - expectedArgs].Value = arg;
                    expectedArgs--;
                    continue;
                }
                // If it gets here, there is something wrong
                throw new ArgumentException(string.Format("Unespected argument '{0}'! Enter '-?' for usage.", arg));
            }
            // Process all the options, in the order that they were created
            foreach (var option in Options)
            {
                foreach (var optionKeyValue in optionList)
                {
                    if (option.Name == optionKeyValue.Key)
                    {
                        try
                        {
                            RunCurrentProcess(optionKeyValue.Value);
                        }
                        catch (Exception e)
                        {
                            errorMessageStr.AppendLine(e.Message);
                        }
                    }
                }
            }
            // After processing all options, process the commands
            foreach (var command in commandList)
            {
                try
                {
                    RunCurrentProcess(command);
                }
                catch (Exception e)
                {
                    errorMessageStr.AppendLine(e.Message);
                }
            }
            // If any errors happened running the options or commands, throw an exception
            if (errorMessageStr.ToString() != "")
            {
                throw new ArgumentException(errorMessageStr.ToString());
            }
        }
 public CommandLineHelper(ArgumentCommand command, List <ArgumentOption> options, ProcessDelegate usage)
     : this(command, options, usage, null)
 {
 }
 public CommandLineHelper(ArgumentCommand command, List <ArgumentOption> options, ProcessDelegate usage, ProcessDelegate emptyArguments)
     : this(command, options, usage, emptyArguments, true /*, false*/)
 {
 }