Slow parsing with IgnoreUnknownArguments = true

[ta-stott-oe]

I find that enabling ParserSettings.IgnoreUnknownArguments can dramatically slow down parsing, even if none of the supplied arguments are unknown.

I've added a small example here to demonstrate this: ta-stott-oe/CommandLineParserTimings

In this demo, the parsing time seems to increase in a non-linear fashion as the number of arguments increases.

Parsing 10 arguments takes > 14 seconds!

This is using CommandLineParser v2.2.1 with .NET Framework 4.6.

[kostasvl]

I wanted to combine multiple command lines into one, and parse it into separate Options objects. I hit the same issue as above. I came up with the following workaround. It won't win any awards, but it makes parsing instant again:

private static bool ParseOptions<T>(IEnumerable<string> arguments, out T options_to_assign) where T: class
{
	// We could have used a custom parser with IgnoreUnknownArguments=true, but that is slow. See https://github.com/commandlineparser/commandline/issues/243.
	// Hence we are filtering the arguments here to only include the ones that the Options class (T) will want to parse.
	IEnumerable<string> filtered_arguments = arguments.Where(argument => typeof(T).GetMembers().Any(member =>
	{
		OptionAttribute option_attribute =
			member.GetCustomAttributes(typeof(OptionAttribute), true).Cast<OptionAttribute>().SingleOrDefault();

		return option_attribute != null && argument.Contains(option_attribute.LongName);
	}));

	T parsed_options = null;

	bool result = Parser.Default.ParseArguments<T>(filtered_arguments).MapResult(
		options => { parsed_options = options; return true; },
		errors => false
	);

	options_to_assign = parsed_options;

	return result;
}

... in Main() ...
if (!ParseOptions(args, out TestOptions1 test_options1))
{
	return;
}
if (!ParseOptions(args, out TestOptions2 test_options2))
{
	return;
}

[moh-hassan]

There is an enhancement for the parser performance.
I did a test for commandLineParser v2.6.0 with 100 argument using the same tool: ta-stott-oe/CommandLineParserTimings
The max time for 100 arg was 647 millisecond (less than one second).
The performance chart:

The data file: timings.zip
Note: timing may be different based on the CPU performance.

[kostasvl]

Thanks! With 2.6.0, parsing is instant again. I was on 2.3.0 without realising.

[moh-hassan]

Glad that your parsing is instant