Лучший способ разобрать аргументы командной строки в C #? [закрыто]

Мне нравится , что один , потому что можно "определить правила" для аргументов, необходимых или нет...

или если Вы - парень Unix, чем Вы, мог бы любить GNU Getopt.NET порт.

Взгляд http://github.com/mono/mono/tree/master/mcs/class/Mono.Options/

Библиотека WPF TestApi идет с одним из самых хороших синтаксических анализаторов командной строки для разработки C#. Я настоятельно рекомендую изучение его, от блог Ivo Manolov на API:

// EXAMPLE #2:
// Sample for parsing the following command-line:
// Test.exe /verbose /runId=10
// This sample declares a class in which the strongly-
// typed arguments are populated
public class CommandLineArguments
{
   bool? Verbose { get; set; }
   int? RunId { get; set; }
}

CommandLineArguments a = new CommandLineArguments();
CommandLineParser.ParseArguments(args, a);

Есть парсер аргументов командной строки на http://www.codeplex.com/commonlibrarynet

Может анализировать аргументы используя
1. атрибуты
2. явные вызовы
3. одна строка из нескольких аргументов ИЛИ строковый массив

. Может обрабатывать такие вещи, как:

- config : Qa - startdate : $ { today } - регион : «Нью-Йорк» Настройки01

Его очень легко использовать.

Синтаксический анализатор командной строки Genghis может быть немного устаревшим, но он очень полнофункциональный и хорошо работает для меня.

Это обработчик, который я написал на основе класса Novell Options .

Это нацелено на консольные приложения, которые выполняют цикл в стиле while (input! = "Exit") , интерактивная консоль, такая как, например, FTP-консоль.

Пример использования:

static void Main(string[] args)
{
    // Setup
    CommandHandler handler = new CommandHandler();
    CommandOptions options = new CommandOptions();

    // Add some commands. Use the v syntax for passing arguments
    options.Add("show", handler.Show)
        .Add("connect", v => handler.Connect(v))
        .Add("dir", handler.Dir);

    // Read lines
    System.Console.Write(">");
    string input = System.Console.ReadLine();

    while (input != "quit" && input != "exit")
    {
        if (input == "cls" || input == "clear")
        {
            System.Console.Clear();
        }
        else
        {
            if (!string.IsNullOrEmpty(input))
            {
                if (options.Parse(input))
                {
                    System.Console.WriteLine(handler.OutputMessage);
                }
                else
                {
                    System.Console.WriteLine("I didn't understand that command");
                }

            }

        }

        System.Console.Write(">");
        input = System.Console.ReadLine();
    }
}

] И источник:

/// <summary>
/// A class for parsing commands inside a tool. Based on Novell Options class (http://www.ndesk.org/Options).
/// </summary>
public class CommandOptions
{
    private Dictionary<string, Action<string[]>> _actions;
    private Dictionary<string, Action> _actionsNoParams;

    /// <summary>
    /// Initializes a new instance of the <see cref="CommandOptions"/> class.
    /// </summary>
    public CommandOptions()
    {
        _actions = new Dictionary<string, Action<string[]>>();
        _actionsNoParams = new Dictionary<string, Action>();
    }

    /// <summary>
    /// Adds a command option and an action to perform when the command is found.
    /// </summary>
    /// <param name="name">The name of the command.</param>
    /// <param name="action">An action delegate</param>
    /// <returns>The current CommandOptions instance.</returns>
    public CommandOptions Add(string name, Action action)
    {
        _actionsNoParams.Add(name, action);
        return this;
    }

    /// <summary>
    /// Adds a command option and an action (with parameter) to perform when the command is found.
    /// </summary>
    /// <param name="name">The name of the command.</param>
    /// <param name="action">An action delegate that has one parameter - string[] args.</param>
    /// <returns>The current CommandOptions instance.</returns>
    public CommandOptions Add(string name, Action<string[]> action)
    {
        _actions.Add(name, action);
        return this;
    }

    /// <summary>
    /// Parses the text command and calls any actions associated with the command.
    /// </summary>
    /// <param name="command">The text command, e.g "show databases"</param>
    public bool Parse(string command)
    {
        if (command.IndexOf(" ") == -1)
        {
            // No params
            foreach (string key in _actionsNoParams.Keys)
            {
                if (command == key)
                {
                    _actionsNoParams[key].Invoke();
                    return true;
                }
            }
        }
        else
        {
            // Params
            foreach (string key in _actions.Keys)
            {
                if (command.StartsWith(key) && command.Length > key.Length)
                {

                    string options = command.Substring(key.Length);
                    options = options.Trim();
                    string[] parts = options.Split(' ');
                    _actions[key].Invoke(parts);
                    return true;
                }
            }
        }

        return false;
    }
}

Некоторое время назад я написал синтаксический анализатор аргументов командной строки C #. Его по адресу: http://www.codeplex.com/CommandLineArguments

У этой проблемы есть множество решений. Для полноты и обеспечения альтернативы, если кто-то желает, я добавляю этот ответ для двух полезных классов в мою библиотеку кода Google .

Первый - это ArgumentList, который отвечает только за анализ параметров командной строки. Он собирает пары «имя-значение», определенные переключателями «/ x: y» или «-x = y», а также собирает список «безымянных» записей. Его основное использование обсуждается здесь , см. Класс здесь .

Вторая часть - это CommandInterpreter , который создает полнофункциональное приложение командной строки из вашего класса .Net. В качестве примера:

using CSharpTest.Net.Commands;
static class Program
{
    static void Main(string[] args)
    {
        new CommandInterpreter(new Commands()).Run(args);
    }
    //example ‘Commands’ class:
    class Commands
    {
        public int SomeValue { get; set; }
        public void DoSomething(string svalue, int ivalue)
        { ... }

В приведенном выше примере кода вы можете запустить следующее:

Program.exe DoSomething «строковое значение» 5

- или -

Program.exe dosomething / ivalue = 5 - svalue: "строковое значение"

Это так просто или так сложно, как вам нужно. Вы можете просмотреть исходный код , просмотреть справку или загрузить двоичный файл .

Похоже, у каждого есть свои любимые парсеры командной строки, полагаю, мне лучше добавить свои :).

http://bizark.codeplex.com/

Эта библиотека содержит парсер командной строки , который инициализирует класс значениями из командной строки. В нем масса функций (я создавал ее много лет).

Из документации ...

Анализ командной строки в платформе BizArk имеет следующие ключевые особенности:

• Автоматическая инициализация: Свойства класса автоматически устанавливаются на основе команды: строковые аргументы.
• Свойства по умолчанию: Отправить значение без указания имени свойства.
• Преобразование значений: Использует мощный класс ConvertEx, также включенный в BizArk, для преобразования значений в правильный тип.
• Логические флаги: Флаги можно указать, просто используя аргумент (например, / b для истины и / b- для ложного) или путем добавления значения истина / ложь, да / нет и т. Д.
• Массивы аргументов: Просто добавьте несколько значений после имени командной строки, чтобы задать свойство, определенное как массив. Пример: / x 1 2 3 заполнит x массивом {1, 2, 3} (при условии, что x определен как массив целых чисел).
• Псевдонимы командной строки: Свойство может поддерживать для него несколько псевдонимов командной строки. Например, в справке используется псевдоним?.
• Частичное распознавание имени: Вам не нужно писать полное имя или псевдоним по буквам, просто достаточно, чтобы синтаксический анализатор отличил свойство / псевдоним от других.
• Поддерживает ClickOnce: Может инициализировать свойства, даже если они указаны как строка запроса в URL-адресе для приложений, развернутых ClickOnce. Метод инициализации из командной строки определит, работает он как ClickOnce или нет, поэтому ваш код не нужно менять при его использовании.
• Автоматически создает /? help: Это включает красивое форматирование, учитывающее ширину консоли.
• Загрузить / сохранить аргументы командной строки в файл: Это особенно полезно, если у вас есть несколько больших сложных наборов аргументов командной строки, которые вы хотите запускать несколько раз.

Я бы предложил библиотеку с открытым исходным кодом CSharpOptParse . Он анализирует командную строку и гидратирует определяемый пользователем объект .NET с помощью ввода командной строки. Я всегда обращаюсь к этой библиотеке при написании консольного приложения на C #.