Question

I am working on my own command line arguments parser and after reading dozens of articles regarding method overloading I am still not certain if I am doing it right.

Am I getting any benefit from overloading methods this way? I know I could just write the entire thing in a single method (with default value parameters) by branching, but I’m experimenting overloads at the moment and I would like to know whether to continue on this path or not.

    public static class MyParsers
    {
        private static List<string> args;

        static MyParsers()
        {
            args = Environment.GetCommandLineArgs().ToList();
        }

        public static List<string> ParseOptions()
        {
            return ParseOptions(false);
        }

        public static List<string> ParseOptions(bool toLowercase)
        {
            // DEBUG: Change command line arguments here.
            var arguments = args;
            return !toLowercase
                       ? arguments
                       : arguments.MyExtToLower();
        }

        public static bool OptionExists(string option)
        {
            return OptionExists(option, false);
        }

        public static bool OptionExists(string option, bool toLowercase)
        {
            var list = ParseOptions(toLowercase);
            for (var i = 1; i < list.Count; i++)
            {
                if (list[i].StartsWith(option)) return true;
            }
            return false;
        }

}

Answer 1

Yes that is the correct way to use overloads.

One thing to note about default parameters.

If you have two assemblies, A and B, A calls the function in B.

If you change the default in B:

using default values for parameters you need to recompile both assembly A and B for this change to take effect

using overloads you only need to recompile B.

This is because for default parameters, at compile time the compiler inserts the default values.