コード例 #1
0
        public string FormatUsage <T>(string appName)
        {
            var usageBuilder = new StringBuilder();

            usageBuilder.AppendLine(
                $@"{appName} <option> <args> [optional parameters]

Options:");

            foreach (var optionInfo in CommandLineOptionsHelper.EnumerateTypeOptionPropertyInfo(null, typeof(T), null))
            {
                if (optionInfo.FormattedShortName != null)
                {
                    usageBuilder.Append(optionInfo.FormattedShortName);
                    if (optionInfo.FormattedLongName != null)
                    {
                        usageBuilder.AppendLine();
                    }
                }

                if (optionInfo.FormattedLongName != null)
                {
                    usageBuilder.Append(optionInfo.FormattedLongName);
                }

                if (optionInfo.OptionAttribute.ArgumentDescription != null)
                {
                    usageBuilder.Append($" <{optionInfo.OptionAttribute.ArgumentDescription}>");
                }

                if (optionInfo.OptionAttribute.Required)
                {
                    usageBuilder.Append(" (required)");
                }

                usageBuilder.AppendLine();

                if (optionInfo.OptionAttribute.Description != null)
                {
                    usageBuilder.AppendLine(optionInfo.OptionAttribute.Description);

                    if (optionInfo.OptionAttribute.DefaultValue != null)
                    {
                        usageBuilder.AppendLine($"Default is {optionInfo.OptionAttribute.DefaultValue}.");
                    }
                }

                usageBuilder.AppendLine();
            }

            return(usageBuilder.ToString());
        }
コード例 #2
0
        public T Parse <T>(string[] args)
        {
            var options = Activator.CreateInstance <T>();
            var lookup  = CommandLineOptionsHelper.BuildOptionNameLookup(options);

            for (int i = 0; i < args.Length; i++)
            {
                var opt = args[i];

                bool TryGetNextArg(out string arg)
                {
                    arg = null;

                    if ((i + 1) > (args.Length - 1))
                    {
                        return(false);
                    }

                    arg = args[++i];
                    return(true);
                }

                string GetNextArg()
                {
                    if (!TryGetNextArg(out var arg))
                    {
                        throw new MissingRequiredArgumentException($"Missing required argument for option: {opt}")
                              {
                                  Option = opt
                              }
                    }
                    ;

                    return(arg);
                }

                if (!lookup.TryGetValue(opt, out CommandLineOptionsHelper.OptionInfo optionInfo))
                {
                    continue;
                }

                if (optionInfo.PropertyInfo.PropertyType == typeof(bool))
                {
                    // Toggle
                    optionInfo.PropertyInfo.SetValue(optionInfo.Object, true);
                }
                else
                {
                    // Simple value assignment
                    var arg       = GetNextArg();
                    var converter = TypeDescriptor.GetConverter(optionInfo.PropertyInfo.PropertyType);
                    var value     = converter.ConvertFromString(null, CultureInfo.InvariantCulture, arg);
                    optionInfo.PropertyInfo.SetValue(optionInfo.Object, value);
                }

                optionInfo.Assigned = true;
            }

            foreach (var lookupKvp in lookup)
            {
                var objProperty = lookupKvp.Value;

                if (!objProperty.Assigned && (objProperty.OptionAttribute != null))
                {
                    if (objProperty.OptionAttribute.Required)
                    {
                        throw new MissingRequiredOptionException($"Missing required option: {lookupKvp.Key}")
                              {
                                  Option = lookupKvp.Key
                              }
                    }
                    ;

                    if (objProperty.OptionAttribute.DefaultValue != null)
                    {
                        objProperty.PropertyInfo.SetValue(objProperty.Object, objProperty.OptionAttribute.DefaultValue);
                    }
                }
            }

            return(options);
        }
    }
}