CommandLineParser.cs

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace hirosof.Application.Process {     
    using CommandLineNamedParameterList = List<CommandLineNamedParameterItem>;
    using CommandLineNamedParameterMultiMap = Dictionary<String, List<String>>;
    using CommandLineUnnamedParameterList = List<String>;


    public class CommandLineNamedParameterItem {
        public string name;
        public string value;

        public CommandLineNamedParameterItem() {
            name = string.Empty;
            value = string.Empty;
        }


        public CommandLineNamedParameterItem(string name, string value) {
            this.name = name;
            this.value = value;
        }

        public CommandLineNamedParameterItem(CommandLineNamedParameterItem item) {
            this.name = item.name;
            this.value = item.value;
        }

        public void Clear() {
            name = string.Empty;
            value = string.Empty;
        }

        public override string ToString() {
            return String.Format("{{0},{1}}", name, value);
        }
    }

    public class CommandLineParser {

        public static CommandLineNamedParameterList doParsing(string[] args) {


            CommandLineNamedParameterList parsedArgs = new CommandLineNamedParameterList();

            CommandLineNamedParameterItem item = new CommandLineNamedParameterItem();

            int name_value_split_pos;
            bool judge_flag_for_next_is_parameter_value = false;


            char[] name_value_split_chars = ":=".ToCharArray();

            foreach (string arg in args) {
                item.Clear();

                if (judge_flag_for_next_is_parameter_value && (parsedArgs.Count > 0)) {
                    judge_flag_for_next_is_parameter_value = false;

                    if ((parsedArgs.Last().name.Length != 0) && (parsedArgs.Last().value.Length == 0)) {
                        item.name = parsedArgs.Last().name;
                        item.value = arg.Trim();
                        parsedArgs.RemoveAt(parsedArgs.Count - 1);
                        parsedArgs.Add(new CommandLineNamedParameterItem(item));
                        continue;
                    }

                }

                if (arg.StartsWith("--")) {
                    item.name = arg.Substring(2).Trim();
                } else if (arg.StartsWith('-') || arg.StartsWith('/')) {
                    item.name = arg.Substring(1).Trim();
                } else if ((arg == ":") || (arg == "=")) {
                    judge_flag_for_next_is_parameter_value = true;
                    continue;
                } else {
                    item.name = string.Empty;
                    item.value = arg.Trim();
                }

                if (item.name.Length > 0) {

                    name_value_split_pos = item.name.IndexOfAny(name_value_split_chars);

                    if (name_value_split_pos != -1) {
                        item.value = item.name.Substring(name_value_split_pos + 1).Trim();
                        item.name = item.name.Substring(0, name_value_split_pos).Trim();
                    }

                }
                parsedArgs.Add(new CommandLineNamedParameterItem(item));
            }
            return parsedArgs;

        }




        public CommandLineParser(string[] args) {
            doClassifying(doParsing(args));
        }

        public CommandLineParser(CommandLineNamedParameterList parsed) {

            doClassifying(parsed);

        }


        private ReadOnlyCollection<CommandLineNamedParameterItem> _unclassifyParameters = new ReadOnlyCollection<CommandLineNamedParameterItem>(new CommandLineNamedParameterList());
        private ReadOnlyDictionary<String, List<String>> _namedParameters = new ReadOnlyDictionary<string, CommandLineUnnamedParameterList>(new CommandLineNamedParameterMultiMap());
        private ReadOnlyCollection<string> _unnamedParameters = new ReadOnlyCollection<string>(new List<string>());

        public ReadOnlyCollection<CommandLineNamedParameterItem> UnclassifyParameters {
            get {
                return _unclassifyParameters;
            }

            private set {

            }
        }
        public ReadOnlyCollection<string> UnnamedParameters {
            get {
                return _unnamedParameters;  
            }

            private set {

            }
        }

        public ReadOnlyDictionary<String, List<String>> NamedParameters { 
            get { 
                return _namedParameters; 
            } 

            private set {

            }
        }



        private void doClassifying(CommandLineNamedParameterList parsed) {

            _unclassifyParameters = new ReadOnlyCollection<CommandLineNamedParameterItem>(parsed);

            CommandLineNamedParameterMultiMap namedParameters = new CommandLineNamedParameterMultiMap();
            CommandLineUnnamedParameterList unnamedParameters = new CommandLineUnnamedParameterList();

            foreach (var parameter in parsed) {
                if (parameter.name.Length == 0) {
                    unnamedParameters.Add(parameter.value);
                } else {
                    if (!namedParameters.ContainsKey(parameter.name)) {
                        namedParameters.Add(parameter.name, new List<string>());
                    }
                    namedParameters[parameter.name].Add(parameter.value);
                }
            }

            _namedParameters = new ReadOnlyDictionary<string, CommandLineUnnamedParameterList>(namedParameters);
            _unnamedParameters = new ReadOnlyCollection<string>(unnamedParameters);

        }


    }


}