AppArgSupport.cs 7.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209
  1. using System;
  2. using System.Collections.Generic;
  3. namespace Wayne.Lib
  4. {
  5. /// <summary>
  6. /// Argument support for parameters passed to the application's Main method.
  7. /// It handles either flags, such as -a /a or just a.
  8. /// Or it handles arguments on the form key=value.
  9. /// </summary>
  10. public class AppArgSupport
  11. {
  12. private readonly Dictionary<string, string> argDict = new Dictionary<string, string>();
  13. private readonly List<string> flagList = new List<string>();
  14. /// <summary>
  15. /// Constructor.
  16. /// </summary>
  17. /// <param name="args"></param>
  18. public AppArgSupport(string[] args)
  19. {
  20. foreach (string arg in args)
  21. {
  22. int equalSignIndex = arg.IndexOf('=');
  23. if (equalSignIndex > -1)
  24. argDict[arg.Substring(0, equalSignIndex).ToUpper()] = arg.Substring(equalSignIndex + 1);
  25. else
  26. {
  27. string flagName = arg;
  28. if (!flagList.Exists(s => s.Equals(flagName, StringComparison.CurrentCultureIgnoreCase)))
  29. flagList.Add(arg);
  30. }
  31. }
  32. }
  33. /// <summary>
  34. /// Checks if the specified flag exists
  35. /// </summary>
  36. /// <param name="flag"></param>
  37. /// <returns></returns>
  38. public bool HasFlag(string flag)
  39. {
  40. return flagList.Exists(s => s.Equals(flag, StringComparison.CurrentCultureIgnoreCase));
  41. }
  42. /// <summary>
  43. /// Tries to get the specified parameter.
  44. /// </summary>
  45. /// <param name="name">name of the parameter</param>
  46. /// <param name="value">value of the parameter</param>
  47. /// <returns>True if the parameter exists</returns>
  48. public bool TryGetArgStringValue(string name, out string value)
  49. {
  50. return argDict.TryGetValue(name.ToUpper(), out value);
  51. }
  52. /// <summary>
  53. /// Gets the argument value as a string
  54. /// </summary>
  55. /// <param name="name"></param>
  56. /// <returns></returns>
  57. public string GetArgStringValue(string name)
  58. {
  59. string value;
  60. if (argDict.TryGetValue(name.ToUpper(), out value))
  61. return value;
  62. throw new ArgumentException(string.Concat("Missing argument \"", name, "\""));
  63. }
  64. /// <summary>
  65. /// Gets the argument value, providing a default value to use in case the parameter is not specified.
  66. /// </summary>
  67. /// <param name="name"></param>
  68. /// <param name="defaultValue"></param>
  69. /// <returns></returns>
  70. public string GetArgStringValue(string name, string defaultValue)
  71. {
  72. string value;
  73. if (!argDict.TryGetValue(name.ToUpper(), out value))
  74. value = defaultValue;
  75. return value;
  76. }
  77. /// <summary>
  78. /// Tries to get an integer argument value.
  79. /// </summary>
  80. /// <param name="name"></param>
  81. /// <param name="value"></param>
  82. /// <returns>True if success.</returns>
  83. public bool TryGetArgIntValue(string name, out int value)
  84. {
  85. try
  86. {
  87. string stringValue;
  88. if (TryGetArgStringValue(name, out stringValue))
  89. {
  90. value = int.Parse(stringValue);
  91. return true;
  92. }
  93. }
  94. catch (Exception) { }
  95. value = 0;
  96. return false;
  97. }
  98. /// <summary>
  99. /// Gets an integer argument value
  100. /// </summary>
  101. /// <param name="name"></param>
  102. /// <returns></returns>
  103. /// <exception cref="ArgumentException">If value does not exist</exception>
  104. /// <exception cref="ArgumentException">If value is not integer</exception>
  105. public int GetArgIntValue(string name)
  106. {
  107. string stringValue = GetArgStringValue(name);
  108. try
  109. {
  110. return int.Parse(stringValue);
  111. }
  112. catch (Exception)
  113. {
  114. throw new ArgumentException(string.Concat("Bad int-value in argument \"", name, "\": \"", stringValue, "\""));
  115. }
  116. }
  117. /// <summary>
  118. /// Gets an integer argument value if exists, otherwise returns the default value.
  119. /// </summary>
  120. /// <param name="name"></param>
  121. /// <param name="defaultValue"></param>
  122. /// <returns></returns>
  123. public int GetArgIntValue(string name, int defaultValue)
  124. {
  125. try
  126. {
  127. string value = GetArgStringValue(name, defaultValue.ToString());
  128. return int.Parse(value);
  129. }
  130. catch (Exception)
  131. {
  132. return defaultValue;
  133. }
  134. }
  135. /// <summary>
  136. /// Gets an enumeration argument value.
  137. /// </summary>
  138. /// <typeparam name="TEnum"></typeparam>
  139. /// <param name="name"></param>
  140. /// <param name="value"></param>
  141. /// <returns>True if success.</returns>
  142. public bool TryGetArgEnumValue<TEnum>(string name, out TEnum value) where TEnum : struct
  143. {
  144. try
  145. {
  146. string stringValue;
  147. if (TryGetArgStringValue(name, out stringValue))
  148. {
  149. value = (TEnum)Enum.Parse(typeof(TEnum), stringValue, true);
  150. return true;
  151. }
  152. }
  153. catch (Exception) { }
  154. value = default(TEnum);
  155. return false;
  156. }
  157. /// <summary>
  158. /// Gets an enumeration argument value.
  159. /// </summary>
  160. /// <typeparam name="TEnum"></typeparam>
  161. /// <param name="name"></param>
  162. /// <returns></returns>
  163. /// <exception cref="ArgumentException">If value does not exist</exception>
  164. /// <exception cref="ArgumentException">If value is not one of the enumerated values</exception>
  165. public TEnum GetArgEnumValue<TEnum>(string name)
  166. {
  167. string stringValue = GetArgStringValue(name);
  168. try
  169. {
  170. return (TEnum)Enum.Parse(typeof(TEnum), stringValue, true);
  171. }
  172. catch (Exception)
  173. {
  174. throw new ArgumentException(string.Concat("Bad enum-value in argument \"", name, "\": \"", stringValue, "\""));
  175. }
  176. }
  177. /// <summary>
  178. /// Gets an enumeration argument value if exists, otherwise returns the default value.
  179. /// </summary>
  180. /// <param name="name"></param>
  181. /// <param name="defaultValue"></param>
  182. /// <returns></returns>
  183. public TEnum GetArgEnumValue<TEnum>(string name, TEnum defaultValue)
  184. {
  185. try
  186. {
  187. string stringValue = GetArgStringValue(name, defaultValue.ToString());
  188. return EnumSupport.Parse(stringValue, true, defaultValue);
  189. }
  190. catch (Exception)
  191. {
  192. return defaultValue;
  193. }
  194. }
  195. }
  196. }