UltraMapper.CommandLine

Ultramapper.Commandline

Um analisador de comando que suporta chamadas de método direto tomando como entrada um número ilimitado de parâmetros primitivos e complexos do tipo

O que é ultramapper.commandline?

Ultramapper.CommandLine é um analisador de linha de comando .NET: uma ferramenta que analisa (analise e interpreta) o texto da linha de comando e mapeia (trasform) em objetos fortemente tipados .

Ultramapper.Commandline simplifica drasticamente seu código:

• Métodos O suporte de chamadas permite que você se livre de todos os 'sinalizadores de comando' e todo o código necessário para lidar com eles
• O suporte do tipo complexo permite que você organize parâmetros logicamente nas classes

Ultramapper.Commandline é alimentado pelo Ultramapper, um poderoso mapeador .NET!

Recursos de mudança de jogo!

• Chamadas de método direto que suportam um número ilimitado de parâmetros de entrada
• Tipos complexos suportam para propriedades e métodos
• Nidificação . Tipos complexos podem definir internamente outros membros do tipo complexo recursivamente.
• A herança do tipo é totalmente suportada.
• Coleções (Ienumerable <>, list <>, matrizes) dos tipos primitivos e complexos suportam
• Um JSON simples como sintaxe que suporta tudo isso!
• Gerador de ajuda automática

Introdução pelo exemplo

Ok, isso terá alguma complexidade, mas eu quero impressioná -lo!

O exemplo a seguir mostra como chamar o método AddTodatabase do CommandLine, passando como entrada de uma representação da string do cliente de complexo bem estruturado CustomerInfo , que o método addTodatabase toma como entrada.

 class Program
{
    static void Main ( string [ ] args )
    {
        //--add ("John Smith" 26 account=(number=AC2903X balance=3500.00 creditcards=[(CRD01 1000.00) (CRD02 2000.00)]))
        CommandLine . Instance . Parse < CommandLineSupportedCommands > ( args ) ;
    }

    public class CommandLineSupportedCommands
    {
        [ Option ( Name = "add" , HelpText = "Adds new customer to db" ) ]
        public void AddToDatabase ( CustomerInfo customer )
        {
            Assert . IsTrue ( customer . Name == "John Smith" ) ;
            Assert . IsTrue ( customer . Age == 26 ) ;
            Assert . IsTrue ( customer . Account . AccountNumber == "AC2903X" ) ;
            Assert . IsTrue ( customer . Account . Balance == 3500 ) ;
            Assert . IsTrue ( customer . Account . CreditCards [ 0 ] . CardNumber == "CRD01" ) ;
            Assert . IsTrue ( customer . Account . CreditCards [ 0 ] . MonthlyLimit == 1000 ) ;
            Assert . IsTrue ( customer . Account . CreditCards [ 1 ] . CardNumber == "CRD02" ) ;
            Assert . IsTrue ( customer . Account . CreditCards [ 1 ] . MonthlyLimit == 2000 ) ;

            Console . WriteLine ( "New customer inserted!" ) ;
        }
    }

    public class CustomerInfo
    {
        public class BankAccountInfo
        {
            public class CreditCardInfo
            {
                public string CardNumber { get ; set ; }
                public double MonthlyLimit { get ; set ; }
            }

            [ Option ( Name = "number" ) ]
            public string AccountNumber { get ; set ; }
            public double Balance { get ; set ; }

            public List < CreditCardInfo > CreditCards { get ; set ; }
        }

        public string Name { get ; set ; }
        public int Age { get ; set ; }

        public BankAccountInfo Account { get ; set ; }
    }
}

O exemplo acima mostra alguns recursos básicos para começar:

• Como analisar argumentos:

   T parsedArgs = CommandLine . Instance . Parse < T > ( args ) ;

  A linha de código acima faz todo o trabalho.
  O argumento genérico t é a sua 'classe de comandos' .
  Na sua 'classe de comandos', você define todas as operações que deseja oferecer suporte ao nível de comando .

• A sintaxe básica:

  • Use - traços duplos para chamar um método ou definir uma propriedade definida na sua 'classe de comandos'
  • Use () suportes redondos para fornecer valores a um tipo complexo
  • Use [] suportes quadrados para fornecer valores a uma coleção
  • Os parâmetros podem ser atribuídos anonimamente ou especificando explicitamente seus nomes (chamados params)

  Isso não é tudo que você precisa saber sobre a sintaxe
  Leia mais sobre a sintaxe aqui

• O atributo de opção:

  • Permite que você substitua o nome de um membro para facilitar a consulta a ele do CommandLine
  • Permite que você marque um membro como opcional
  • Permite fornecer uma descrição de ajuda que será usada pelo comando de ajuda autogenerado .

  Isso não é tudo que você precisa saber sobre o atributo de opção
  Leia mais sobre o atributo de opção aqui

Há mais algumas coisas e algumas observações que você deve saber sobre ultramapper.Commandline
Confira o wiki para obter mais informações

Qualquer feedback é bem -vindo