Parsing command line arguments with C# & LINQ

Whenever I sit down to write an application (mostly a console application), I find myself wishing I had some code I could just drop in to parse command line arguments with. A friend of mine has authored the excellent ConsoleFX library, and it’s really good if you want to do heavy processing, validations and complex command line argument structures with help. Most of the time, however, I don’t.

So I spent the better part of my evening writing something that I hope I will be able to carry around as a code snippet small enough to use anytime, anywhere in an elegant fashion.

#region CommandLine



static class CommandLine


{


	public class Switch // Class that encapsulates switch data. Not meant for direct use.


	{


		public Switch(string name, Action<IEnumerable<string>> handler, string shortForm = null)


		{


			Name = name;


			Handler = handler;


			ShortForm = shortForm;


		}



		public string Name


		{


			get;


			private set;


		}


		public string ShortForm


		{


			get; private set;


		}


		public Action<IEnumerable<string>> Handler


		{


			get; private set;


		}



		public int InvokeHandler(string[] values)


		{


			Handler(values);


			return 1;


		}


	}



	// The regex that extracts names and comma-separated values for switches 


	// in the form (<switch>[:value,value,value])+


	private static readonly Regex _regex =


		new Regex(@"\s*(?<switch>(?<name>\w+)(:\s*(?<value>\w+(\s*,\s*\w+)*))?)",


			RegexOptions.Compiled | RegexOptions.CultureInvariant |


			RegexOptions.ExplicitCapture | RegexOptions.IgnoreCase);



	private const string NameGroup = "name"; // Names of capture groups


	private const string ValueGroup = "value";



	public static void Process(this string[] args, Action printUsage, params Switch[] switches)


	{


		// Run through all matches in the concatenated argument list and if any


		// of the switches match, get the values and invoke the handler we were


		// given. We do a Sum() here for 2 reasons; a) To actually run the handlers


		// and b) see if any were invoked at all (each returns 1 if invoked).


		// If none were invoked, we simply invoke the printUsage handler.


		if ((from Match match in _regex.Matches(string.Join(" ", args))


			 from arg in switches


			 where match.Success &&


				   ((string.Compare(match.Groups[NameGroup].Value, arg.Name, true) == 0) ||


					(string.Compare(match.Groups[NameGroup].Value, arg.ShortForm, true) == 0))


			 select arg.InvokeHandler(match.Groups[ValueGroup].Value.Split(','))).Sum() == 0)


			printUsage(); // We didn't find any switches


	}


}



#endregion

All of the magic happens inside the Process method, where the query tries to match the arguments against the ones we want to check for. The .Sum() aggregate method does two things.

1. It enumerates the elements of the IQueryable, actually calling the handlers in the process. Nothing happens till then!
2. Each of the InvokeHandler calls returns 1, so the result of the .Sum() is 0 if there were no matches (which is when we call the supplied printUsage handler).

Neat, huh? Using it is even simpler!

            args.Process(


                () => Console.WriteLine("Usage is switch0:value switch:value switch2"),


                new CommandLine.Switch("switch0",


                    val => Console.WriteLine("switch 0 with value {0}",


                        string.Join(" ", val))),



                new CommandLine.Switch("switch1",


                    val => Console.WriteLine("switch 1 with value {0}",


                        string.Join(" ", val)), "s1"),



                new CommandLine.Switch("switch2",


                    val => Console.WriteLine("switch 2 with value {0}",


                        string.Join(" ", val))));


        }

Any handlers you provide will be called for each switch or it’s shortform(if found, of course). Now get started writing those fantastic console applications.

Obligatory disclaimer and License: The code above is for you to do whatever you want to. Even if it blows you up (like Dr. Manhattan blows Rorschach up), don’t come back from the dead to haunt me. I would, however appreciate it if you kept the comment attributing that code to me.