Feedback

C# - Klasse ArgumentInfo - Befehlzeilenargumente auswerten

Veröffentlicht von am 11.10.2012
(1 Bewertungen)
Hi Leute

Ok, ich sehe ein, es ist entgegen der Snippet-Definition (kurze, nicht autonome Code-Fragmente) eine etwas gross geratene Geschichte geworden. Aber vielleicht kann der/die Eine oder Andere trotzdem was dabei abgewinnen.

Im Prinzip geht es darum, dass der Klasse ArgumentInfo im Konstruktor der oder ein Argument-Array (string[] args) übergeben werden kann und die Klasse dann die Auswertung automatisch ausführt.

Folgende Typen von Argumenten werden dabei erkannt:

- Flags: Sind einzelne, zB. mit Minus einleitende Optionen ohne weitere
Angaben. Zum Beispiel: "-a", "-DEBUG"

- Options: Sind einzelne, mit Minus einleitende Optionen mit weiteren
Parametern. Falls Auflistungen durch Semikolon (;) getrennt
angegeben werden, werden diese auf Wunsch als List<string>
aufgelöst (Kontruktor-Parameter: resolveLists)
Beispiele: "-a:test" oder "-a:test1;test1;test3;..."

- Parms: Sind einzelne Angaben ohne anführendes Minus, also normale
Eingabeparameter wie zb: "C:\Windows"

Es kann danach mittels HasFlags, HasOptions und HasParms abgefragt werden, ob entsprechende Argumente vorkommen. Durch HasFlag(string) und HasOption(string) kann die Existenz eines konkreten Arguments erfragt werden. Options können auch Auflistungen enthalten, dies kann mittels IsOptionList(string) geprüft werden. Die restlichen Argumente werden als Parameter im Attribut 'Parms' zur Verfügung gestellt.

Trotz des unüblich grossen Umfangs hoffe ich, dass die Klasse klasse ist und dabei hilft, sich mit Wichtigerem beschäftigen zu können ;)
namespace DotNetLab
{
   public sealed class ArgumentInfo
   {
      const string DEFAULT_OPTIONFLAGCHAR = "-";
      const string DEFAULT_OPTIONSEPARATOR = ":";
      const string DEFAULT_OPTIONLISTSEPARATOR = ";";

      #region [ === PUBLIC ATTRIBUTES === ]
      /// <summary>
      /// Flags sind einzelne Einstellungen ohne weitere Angaben
      /// zB. '-a' oder '-DEBUG'
      /// </summary>
      public List<string> Flags { get; private set; }
      /// <summary>
      /// Options sind Einstellungen mit einem oder mehreren Parametern
      /// zB. '-a:test' oder '-DEBUG:on' oder 'f:test1;test2;test3'
      /// </summary>
      public Dictionary<string, object> Options { get; private set; }
      /// <summary>
      /// Parms sind normale Eingabe-Parameter
      /// zB. 'C:\Programme' oder '*.*' etc.
      /// </summary>
      public List<string> Parms { get; private set; }
      /// <summary>
      /// Liefert true, falls Flags in den Argumenten vorhanden sind (-x)
      /// </summary>
      public Boolean HasFlags { get { return Flags.Count > 0; } }
      /// <summary>
      /// Liefert true, falls Optionen in den Argumenten vorhanden sind (-x:a;b;..)
      /// </summary>
      public Boolean HasOptions { get { return Options.Count > 0; } }
      /// <summary>
      /// Liefert true, falls Parms in den Arguemnten vorhanden sind
      /// </summary>
      public Boolean HasParms { get { return Parms.Count > 0; } }
      /// <summary>
      /// Zeichen für die Einleitung einer Option oder eines Flags
      /// Standard: "-" zB. -a
      /// </summary>
      public String OptionFlagChar { get; set; }
      /// <summary>
      /// Zeichen für die Trennung von Option und Optionswert
      /// Standard: ":" zB. -a:xyz
      /// </summary>
      public String OptionSeparator { get; set; }
      /// <summary>
      /// Zeichen für die Trennung von Listen im Optionswert
      /// Standard: ";" zb. -a:x;y;z
      /// </summary>
      public String OptionListSeparator { get; set; }
      #endregion
      #region [ === CONSTRUCTION === ]
      /// <summary>
      /// Konstruktor, analysiert und speichert die Argumentinformationen
      /// </summary>
      /// <param name="arguments">Arguments, welche von Main() übergeben werden</param>
      /// <param name="resolveLists">Gibt an, ob Aufzählungen als List übersetzt werden soll </param>
      public ArgumentInfo(string[] arguments, bool resolveLists)
      {
         OptionFlagChar = DEFAULT_OPTIONFLAGCHAR;
         OptionSeparator = DEFAULT_OPTIONSEPARATOR;
         OptionListSeparator = DEFAULT_OPTIONLISTSEPARATOR;

         Flags = new List<string>();
         Options = new Dictionary<string, object>();
         Parms = new List<string>();

         foreach(string s in arguments)
         {
            if(s.StartsWith(OptionFlagChar)) // Prüfen auf Flag oder Option
            {
               string cleanstr = s.Substring(1, s.Length - 1); // Vorangehendes FlagChar entfernen
               if(cleanstr.Contains(OptionSeparator)) // Prüfen auf Option
               {
                  // OPTION
                  string[] sp = cleanstr.Split(new string[] { OptionSeparator }, StringSplitOptions.RemoveEmptyEntries);
                  if(sp[1].Contains(OptionListSeparator))
                  {
                     if(resolveLists)
                     {
                        // OPTION MIT AUFLISTUNG in List<> auflösen
                        string[] spp = sp[1].Split(new string[] { OptionListSeparator }, StringSplitOptions.RemoveEmptyEntries);
                        List<string> list = new List<string>();
                        foreach(string spps in spp)
                           list.Add(spps);
                        Options.Add(sp[0], list);
                     }
                     else
                     {
                        Options.Add(sp[0], sp[1]);
                     }
                  }
                  else
                  {
                     // OPTION OHNE AUFLISTUNG
                     Options.Add(sp[0], sp[1]);
                  }
               }
               else
               {
                  // FLAG
                  Flags.Add(cleanstr);
               }
            }
            else
            {
               // NORMALER PARAMETER
               Parms.Add(s);
            }
         }
      }
      #endregion
      #region [ === PUBLIC METHODS === ]
      /// <summary>
      /// Überprüfen, ob ein Flag in den Argumenten vorhanden ist
      /// </summary>
      /// <param name="flag">Flag (ohne Minus)</param>
      /// <returns></returns>
      public Boolean HasFlag(string flag)
      {
         return Flags.Contains(flag);
      }
      /// <summary>
      /// Überprüfen, ob eine Option in den Argumenten vorhanden ist
      /// </summary>
      /// <param name="option">Option (ohne Minus)</param>
      /// <returns></returns>
      public Boolean HasOption(string option)
      {
         return Options.ContainsKey(option);
      }
      /// <summary>
      /// Prüfen, ob eine Option als Liste übersetzt worden ist (a;b;c -> List<string>)
      /// </summary>
      /// <param name="option">Option (ohne Minus)</param>
      /// <returns></returns>
      public Boolean IsOptionList(string option)
      {
         bool result = false;
         if(HasOption(option))
         {
            result = (Options[option] is List<string>);
         }
         return result;
      }
      #endregion
   }
}

Kommentare zum Snippet

 

Logge dich ein, um hier zu kommentieren!