Ripulire flusso di controllo quando si tratta di argomenti della riga di comando [C #]

Question

ho a che fare con un programma che fa un sacco di if ... else ramificazione sulla base di argomenti della riga di comando. Questo è in C #, ma io sono sicuro che è applicabile a Java, C ++ ecc Ecco il quadro generale:

if (args.Length == 0)
{
  //do something
}

if (args.Length > 0 && args.Length < 2)
    {
        Console.WriteLine("Only one argument specified. Need two arguments");
        return 0;

    }
            else if (args.Length > 0 && args.Length >= 2)
            {
                //Process file - Argument 1
                if(args[0].Trim() == PROCESS_OPTION_ONE
                    || args[0].Trim() == PROCESS_OPTION_TWO)
                {
                    //Process file - Argument 2
                    if(args[1].Trim() == PROCESS_CUSTOMER
                        || args[1].Trim() == PROCESS_ADMIN
                        || args[1].Trim() == PROCESS_MEMBER
                        || args[1].Trim() == PROCESS_GUEST
                        || args[1].Trim() == PROCESS_USER
                        )
                    {

Quindi, come si può dire, si tratta di una specie di pasticcio. C'è un modello di progettazione o due che sarebbe più applicabile verso la pulizia le cose un po '? modello di comando, forse? Grazie per i consigli e suggerimenti.

Answer 1

Sono parziale utilizzando istruzioni switch sull'array argomenti e impostazione delle proprietà in una classe di configurazione di qualche tipo per ogni argomento previsto. Sembra ci si aspetta una stringa argomento molto specifico formattato piuttosto che permettere valori impostati, si potrebbe provare:

if(args[0].Trim() == PROCESS_OPTION_ONE || args[0].Trim() == PROCESS_OPTION_TWO) 
{ 
    //Process file - Argument 2
    switch(args[1].Trim()
    {
        case PROCESS_CUSTOMER, PROCESS_ADMIN, PROCESS_MEMBER, PROCESS_GUEST, PROCESS_USER:
            // Do stuff
            break;
        default:
            // Do other stuff
            break;
    }
}

Il mio metodo preferito sarebbe qualcosa di simile

foreach(string arg in args)
{
    switch(arg)
    {
        case PROCESS_CUSTOMER:
            // Set property
            break;
        ...
        default:
            // Exception?
            break;
    }
}

NOTA: args.Length == 1 è più veloce di args.Length> 0 && args.Length <2. E 'anche un po' più leggibile

Answer 2

Interrompi la nidificazione.

È possibile passare come (1) Joel ha detto, oppure si può semplicemente rompere la logica in chiamate di metodo chiaro.

if(args.Length <= 1)
{
  Console.WriteLine("Need 2 args kthx");
  return;
}
if(args.Length > 2)
{
  Console.WriteLine("More than 2 args don't know what do");
  return;
}

var arg1 = args[0].Trim();
var arg2 = args[1].Trim();

switch(arg1)
{
  case PROCESS_OPTION_ONE:
     ProcessOptionOne(arg2);
     break;
  case PROCESS_OPTION_TWO:
     ProcessOptionTwo(arg2);
     break;
  default:
     Console.WriteLine("First arg unknown I give up");
     return;
}

poi, nei tuoi metodi di processo ...

private static void ProcessOptionTwo(string argumentTwo)
{
  if(argumentTwo == PROCESS_CUSTOMER ||
     argumentTwo  == PROCESS_ADMIN ||
     /* etc blah blah */
}

Tieni i tuoi metodi più semplice possibile e rompere più, confondendo gli algoritmi in chiamate di metodo distinte che, attraverso il loro nome, danno una chiara indicazione di ciò che stanno facendo.

Answer 3

Non è necessario il else se hai già tornato. Che potrebbe tagliare fuori un sacco di nidificazione. Si potrebbe anche provare a utilizzare un interruttore invece di un gruppo di if nidificati.

Answer 4

il codice da questo articolo Codice progetto molto tempo fa e reso la mia versione di esso da utilizzare per le applicazioni a riga di comando. Ho fatto le mie modifiche ad esso, come fare la classe eredita da dizionario, ecc Ma la parte regex del codice è molto buona, e fa questo genere di riga di comando facile come torta.