How can I obtain the named arguments from a console application in the form of a Dictionary<string,string>?

c# .net string parsing console-application

32,085

Solution 1

Use this Nuget package

V1.9.x - Command Line Parser Library ^{(CodePlex - Going away soon and out of date)}
V2+ - Command Line Parser ^{(Ongoing support)}

Takes seconds to configure and adds instant professional touch to your application.

// Define a class to receive parsed values
class Options {
  [Option('r', "read", Required = true,
    HelpText = "Input file to be processed.")]
  public string InputFile { get; set; }

  [Option('v', "verbose", DefaultValue = true,
    HelpText = "Prints all messages to standard output.")]
  public bool Verbose { get; set; }

  [ParserState]
  public IParserState LastParserState { get; set; }

  [HelpOption]
  public string GetUsage() {
    return HelpText.AutoBuild(this,
      (HelpText current) => HelpText.DefaultParsingErrorsHandler(this, current));
  }
}

// Consume them
static void Main(string[] args) {
  var options = new Options();
  if (CommandLine.Parser.Default.ParseArguments(args, options)) {
    // Values are available here
    if (options.Verbose) Console.WriteLine("Filename: {0}", options.InputFile);
  }
}

Solution 2

Here's how this can be done in the most simple way:

    static void Main(string[] args)
    {
        var arguments = new Dictionary<string, string>();

        foreach (string argument in args)
        {
            string[] splitted = argument.Split('=');

            if (splitted.Length == 2)
            {
                arguments[splitted[0]] = splitted[1];
            }
        }
    }

Note that:

Argument names are case sensitive
Providing the same argument name more than once does not produce an error
No spaces are allowed
One = sign must be used

Solution 3

if you have a "=" in your parameter values, a safer option would be:

private static Dictionary<string, string> ResolveArguments(string[] args)
{
    if (args == null)
        return null;

    if (args.Length > 0)
    {
        var arguments = new Dictionary<string, string>();
        foreach (string argument in args)
        {
            int idx = argument.IndexOf('=');
            if (idx > 0)
                arguments[argument.Substring(0, idx)] = argument.Substring(idx+1);
        }
        return arguments;
    }

    return null;
}

Solution 4

I don't see why this code is bad? hova?

        var arguments = new Dictionary<string, string>();
        foreach (var item in Environment.GetCommandLineArgs())
        {
            try
            {
                var parts = item.Split('=');
                arguments.Add(parts[0], parts[1]);
            }
            catch (Exception ex)
            {
                // your error handling here....
            }

View more solutions

32,085

vel

Updated on June 09, 2021

Comments

vel almost 3 years
I have a console application called MyTool.exe

What is the simplest way to collect the named arguments passed to this console applicaiton and then to put them in a Dictionarty<string, string>() which will have the argument name as the key and the value as the argument?

for example:
```
MyTool foo=123432 bar=Alora barFoo=45.9
```
I should be able to obtain a dictionary which will be:
```
MyArguments["foo"]=123432 
MyArguments["bar"]="Alora"
MyArguments["barFoo"]="45.9"
```
- John Mitchell almost 12 years
  
  Couldn't you use a more standard format thus allowying your appliction to interop with others better? Have a peek at stackoverflow.com/questions/491595/…
Paul almost 12 years

Overwriting a key is a deadly type of "silent error". The program does not complain, and misinterprets what the user specifies. Granted for the majority of cases it won't matter.
Kay Zed almost 12 years

hova: this serves as an example.
WernerCD almost 8 years

2.0.*-beta seems to change things a little: github.com/gsscoder/commandline - including a different options layout.
Mrchief almost 8 years

@WernerCD Guess we need to update this answer once it gets released. Thanks for pointing it out.
Cityonhill93 over 6 years

It seems to me that instead of "if (args.Length > 1)", you should have "if (args.Length >= 1)" or "if (args.Length > 0)". In the case of exactly 1 argument, your code returns null.
essential over 4 years

why have you put Environment.GetCommandLineArgs instead of just args?
Stig over 4 years

Then, the code example is independent of where you run it, just paste it in somewhere, and it will run.
Christiano Kiss over 3 years

This is my approach, as well. I like the concept of using "pure" C# and .NET as opposed to third-party libs, when viable.