C # Compacto-Marco de comandos de usar analizador de línea

Question

He leído esta pregunta: Analizador de línea de comandos para .NET .

Yo creía que era lo que estaba buscando, pero la biblioteca de línea de comandos Biblioteca Analizador no es compacto marco amigable ...

realmente no quieren escribir un programa de análisis de CL y he estado a la deriva lejos del verdadero propósito de mi pequeña aplicación debido a este desafortunado juicio.

¿Alguien sabe de una biblioteca que se ajuste al marco compacto? (De preferencia con la simplicidad y la funcionalidad como el mencionado anteriormente)
No importa si la versión 2 o 3.5

Answer 1

Esto es lo que estoy usando. Lo pedí prestado a alguna parte, pero no sabe dónde:

using System.Collections.Specialized;
using System.Text.RegularExpressions;

/// <summary>
/// Parses the command line arguments into a name/value collection
/// </summary>
public class CommandLineArgumentParser
{
    #region Fields
    private StringDictionary parameters;
    #endregion

    #region Constructors
    /// <summary>
    ///     Initializes a new instance of the <see cref="CommandLineArgumentParser"/> class.
    /// </summary>
    /// <param name="args">command-line arguments
    /// </param>
    public CommandLineArgumentParser(string[] args)
    {
        this.parameters = new StringDictionary();
        Regex spliter = new Regex(@"^-{1,2}|^/|=|:", RegexOptions.IgnoreCase | RegexOptions.Compiled);

        Regex remover = new Regex(@"^['""]?(.*?)['""]?$", RegexOptions.IgnoreCase | RegexOptions.Compiled);

        string parameter = null;
        string[] parts;

        // Valid parameters forms:
        // {-,/,--}param{ ,=,:}((",')value(",'))
        // Examples: 
        // -param1 value1 --param2 /param3:"Test-:-work" 
        //   /param4=happy -param5 '--=nice=--'
        foreach (string txt in args)
        {
            // Look for new parameters (-,/ or --) and a
            // possible enclosed value (=,:)
            parts = spliter.Split(txt, 3);

            switch (parts.Length)
            {
                // Found a value (for the last parameter 
                // found (space separator))
                case 1:
                    if (parameter != null)
                    {
                        if (!this.parameters.ContainsKey(parameter))
                        {
                            parts[0] = remover.Replace(parts[0], "$1");

                            this.parameters.Add(parameter, parts[0]);
                        }

                        parameter = null;
                    }

                    // else Error: no parameter waiting for a value (skipped)
                    break;

                // Found just a parameter
                case 2:
                    // The last parameter is still waiting. 
                    // With no value, set it to true.
                    if (parameter != null)
                    {
                        if (!this.parameters.ContainsKey(parameter))
                        {
                            this.parameters.Add(parameter, "true");
                        }
                    }

                    parameter = parts[1];
                    break;

                // Parameter with enclosed value
                case 3:
                    // The last parameter is still waiting. 
                    // With no value, set it to true.
                    if (parameter != null)
                    {
                        if (!this.parameters.ContainsKey(parameter))
                        {
                            this.parameters.Add(parameter, "true");
                        }
                    }

                    parameter = parts[1];

                    // Remove possible enclosing characters (",')
                    if (!this.parameters.ContainsKey(parameter))
                    {
                        parts[2] = remover.Replace(parts[2], "$1");
                        this.parameters.Add(parameter, parts[2]);
                    }

                    parameter = null;
                    break;
            }
        }

        // In case a parameter is still waiting
        if (parameter != null)
        {
            if (!this.parameters.ContainsKey(parameter))
            {
                this.parameters.Add(parameter, "true");
            }
        }
    }
    #endregion

    #region Properties
    /// <summary>
    /// Gets a count of command line arguments
    /// </summary>
    public int Count
    {
        get
        {
            return this.parameters.Count;
        }
    }

    /// <summary>
    /// Gets the value with the given parameter name
    /// </summary>
    /// <param name="param">name of the parameter</param>
    /// <returns>the value of the parameter</returns>
    public string this[string param]
    {
        get
        {
            return this.parameters[param];
        }
    }
    #endregion
}

Answer 2

he desarrollado este marco, tal vez ayuda a:

El SysCommand es un poderoso marco multiplataforma, para desarrollar aplicaciones de consola en .NET. Es simple, de tipo seguro, y con grandes influencias del patrón MVC.

https://github.com/juniorgasparotto/SysCommand

namespace Example.Initialization.Simple
{
    using SysCommand.ConsoleApp;

    public class Program
    {
        public static int Main(string[] args)
        {
            return App.RunApplication();
        }
    }

    // Classes inheriting from `Command` will be automatically found by the system
    // and its public properties and methods will be available for use.
    public class MyCommand : Command
    {
        public void Main(string arg1, int? arg2 = null)
        {
            if (arg1 != null)
                this.App.Console.Write(string.Format("Main arg1='{0}'", arg1));
            if (arg2 != null)
                this.App.Console.Write(string.Format("Main arg2='{0}'", arg2));
        }

        public void MyAction(bool a)
        {
            this.App.Console.Write(string.Format("MyAction a='{0}'", a));
        }
    }
}

---

Pruebas:

// auto-generate help
$ my-app.exe help

// method "Main" typed
$ my-app.exe --arg1 value --arg2 1000

// or without "--arg2"
$ my-app.exe --arg1 value

// actions support
$ my-app.exe my-action -a

Answer 3

http://commandline.codeplex.com/ he utilizado tantas veces me' he perdido la cuenta. Tal vez funcione para CE. Si no, se va a proporcionar un punto de partida fantástico.