Simple command line parser

I have tried 3-4 different nuget packages for command line parsing. Didn’t figure out how to use them properly. Here is a small command line parser.

Usage example

Here is how I use it.

internal class Program
{
    private static void Main(string[] args)
    {
        var parser = new SimpleCommandLineParser();
        parser.Parse(args);

        if (parser.Arguments.ContainsKey("server"))
        {
            var server = new LoadTestServer();
            server.Start(int.Parse(parser.Arguments["server"][0]));
            Console.WriteLine("Server started");
        }
        else if (parser.Arguments.ContainsKey("client"))
        {
            var client = new LoadTestClient(parser.Arguments["client"][0]);
            client.Start();
            Console.WriteLine("All enqueued");
        }
        else
        {
            Console.WriteLine("SharpMessaging.BenchmarkApp");
            Console.WriteLine(" - Check the app.config for additional configuration options");
            Console.WriteLine();
            Console.WriteLine("SharpMessaging.BenchmarkApp -server [port]");
            Console.WriteLine("SharpMessaging.BenchmarkApp -client [host:port]");
            return;
        }

        Console.WriteLine("Press ENTER to quit");
        Console.ReadLine();
    }
}

Code

And the actual code:

public class SimpleCommandLineParser
{
    public SimpleCommandLineParser()
    {
        Arguments = new Dictionary<string, string[]>();
    }

    public IDictionary<string, string[]> Arguments { get; private set; }

    public void Parse(string[] args)
    {
        var currentName = "";
        var values = new List<string>();
        foreach (var arg in args)
        {
            if (arg.StartsWith("-"))
            {
                if (currentName != "")
                    Arguments[currentName] = values.ToArray();

                values.Clear();
                currentName = arg.Substring(1);
            }
            else if (currentName == "")
                Arguments[arg] = new string[0];
            else
                values.Add(arg);
        }

        if (currentName != "")
            Arguments[currentName] = values.ToArray();
    }

    public bool Contains(string name)
    {
        return Arguments.ContainsKey(name);
    }
}

Features

The great thing is that .NET have already done an initial parse for you. You can for instance use quotes in it to get everything in the same argument:

someApplication "this is argv[0]"

My parser parses the following:

someApp -server 8344 arg2

as

Console.WriteLine(parser.Arguments["server"][0]); //8334
Console.WriteLine(parser.Arguments["server"][1]); //arg2

While this:

someApp server verbose

can be checked as:

Console.WriteLine(parser.Arguments.ContainsKey["server"]);
Console.WriteLine(parser.Arguments.ContainsKey["verbose"]);

i.e. strings that are specified before the first dash argument (“-arg”) will be considered to be an argument by itself.








Running services in long lived applications in .NET

You have probably created a windows service or other types of applications where you have code which need to be run in the background to not block the main thread. To do that you have different types of solutions in .NET, for instance Threads, Timers and Tasks. However, you need to construct them manually, make sure that they do not throw unhandled exceptions etc.

Griffin.Framework provides a simpler solution where you only need to implement a small interface. The library also have full support for your favorite inversion of control container, which enables to to use dependency injection in your application services.

Continue Reading



Pages:1234567...14