C# - Befehlszeilenargumente verwenden

using System;
using System.Collections.Generic;

//
// Erkennt automatisch die per Befehlszeile übergebenen Argumente und kann diese auch widergeben.
// Es werden zwei Formen von Befehlen untersützt:
//      /<Name>:<Wert>
//      /<Name>
//      * der Wert kann auch mit Anführungszeichen "<wert>" bezeichnet werden, wmot im Wert auch Leerzeichen vorkommen dürfen. 
//
// Eine Befehlszeile besteht aus mehren solcher Argumente aneinander gereiht und durch ein Leerzeichen getrennt.
//  Beispiel eines gültigen Befehlszeile: /run /user:admin /info:"Hallo Welt"
//
public sealed class ArgumentParser
{
    private List<ArgumentDescription> m_descriptions;

    //
    // Erwartet die Befehlszeile, wie sie vom system erstellt wurde.
    // Die Main(string[] args)-Methode stellt diese in form von @args zur Verfügung.
    // Ansonnstne kann man auch die System.Environment.GetCommandLineArgs()-Methode als
    // Quelle verwenden.
    //
    public static ArgumentParser Create(string[] commands)
    {
        List<ArgumentDescription> d = new List<ArgumentDescription>();

        foreach (var item in commands)
        {
            string normal = item.Substring(1); // Das erste Zeichen entfernen
            if (normal.Contains(':')) // Hat zusätzliches Argument
            {
                // 1. Teil: Name / 2. Teil: Wert
                string[] parts = normal.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
                d.Add(new ArgumentDescription(parts[0], parts[1]));
            }
            else // Nur ein Parameter
            {
                d.Add(new ArgumentDescription(normal));
            }
        }

        return new ArgumentParser(d);
    }

    private ArgumentParser(List<ArgumentDescription> args)
    {
        m_descriptions = args;
    }

    //
    // Gibt das passende Element mit dem Namen oder null zurück.
    //
    public ArgumentDescription GetForName(string name)
    {
        foreach (var item in m_descriptions)
        {
            if (item.Name == name)
                return item;
        }
        return null;
    }

    //
    // Gibt die Argumente in rohform zurück.
    //
    public ArgumentDescription[] GetArguments()
    {
        return m_descriptions.ToArray();
    }
}

//
// Beschreibt eine Argument aus der Befehlszeile.
// Immer ist der Name vorhanden, in bestimmten Fällen aber auch noch ein Wert.
//
public sealed class ArgumentDescription
{
    private string m_name;
    private string m_value;

    public string Name { get { return m_name; } }
    public string Value { get { return m_value; } } // Kann auch null sein

    public ArgumentDescription(string name, string value = null)
    {
        m_name = name;
        m_value = value;
    }

    //
    // Gibt an, ob es überhaupt einen Wert gibt.
    // Nur bei Argumenten der Form /<name>:<wert> gibt es einen Wert
    //
    public bool HasValue
    {
        get
        {
            return Value != null;
        }
    }
}