Entwurfsmuster für Befehlszeilensoftware mit mehreren Funktionen

Question

Ich entwickle ein Programm, das von der Befehlszeile aufgerufen wird. Die Software wird eine Art "Kit" mit unterschiedlicher Funktionalität sein, basierend auf den verschiedenen Flags, die beim Aufruf des Programms definiert wurden. Einige dieser Funktionen unterscheiden sich stark von anderen und die einzige Ähnlichkeit ist die Art der Datei, auf der sie ausgeführt wird.

Ich frage mich, was das beste Entwurfsmuster ist, um diese Art von Funktionalität zu implementieren? Ich habe über das Fassadenentwurfsmuster gelesen, das jedes Modul in ein anderes Untersystem aufteilt. Jedes Stück Funktionalität unter einer anderen Fassade zu bauen, würde es modular halten und es mir erlauben, eine einzige Klasse zu bauen, die mit der zu rufenden Fassade umgehen kann.

Ist dies der beste Weg, oder würden Sie etwas anderes empfehlen?

Danke, Sam

Answer 1

Da dies eine Befehlszeilenanwendung ist, denke ich, die Command pattern könnte für Sie nützlich sein. Persönlich glaube ich, dass dies eine gute Möglichkeit ist, Konsolen-Apps zu strukturieren.

Dies ist eine mögliche Implementierung (in C#), um mehrere Befehle zu unterstützen:

// The main class, the entry point to the program 
internal class Program 
{ 
    private static void Main(string[] args) 
    { 
     var p = new Processor(); 
     p.Process(args); 
    } 
} 

/* La clase de procesador de comandos, básicamente toma sus parámetros de entrada para crear el comando que necesita ejecutar y ejecuta el comando. */ 
public class Processor 
{ 
    private CommandFactory _commandFactory; 

    public Processor() 
    { 
     _commandFactory = new CommandFactory(); 
    } 

    public void Process(string[] args) 
    { 
     var arguments = ParseArguments(args); 
     var command = _commandFactory.CreateCommand(arguments); 

     command.Execute(); 
    } 

    private CommandArguments ParseArguments(string[] args) 
    { 
     return new CommandArguments 
     { 
      CommandName = args[0] 
     };   
    } 
} 

/* Creates a command based on command name */ 
public class CommandFactory 
{ 
    private readonly IEnumerable<ICommand> _availableCommands = new ICommand[] 
        { 
         new Command1(), new Command2(), ..... 
        }; 

    public ICommand CreateCommand(CommandArguments commandArguments) 
    { 
     var result = _availableCommands.FirstOrDefault(cmd => cmd.CommandName == commandArguments.CommandName); 
     var command = result ?? new NotFoundCommand { CommandName = commandArguments.CommandName }; 
     command.Arguments = commandArguments; 

     return command; 
    } 
} 

public interface ICommand 
{ 
    string CommandName { get; } 
    void Execute(); 
} 

/* One of the commands that you want to execute, you can create n implementations of ICommand */ 
public class Command1 : ICommand 
{ 
    public CommandArguments Arguments { get; set; } 

    public string CommandName 
    { 
     get { return "c1"; } 
    } 

    public void Execute() 
    { 
     // do whatever you want to do ... 
     // you can use the Arguments 
    } 
} 


/* Null object pattern for invalid parametters */ 
public class NotFoundCommand : ICommand 
{ 
    public string CommandName { get; set; } 

    public void Execute() 
    { 
     Console.WriteLine("Couldn't find command: " + CommandName); 
    } 
} 

Answer 2

Sie könnten das strategy pattern prüfen wollen:

das Strategie-Muster (auch als Politikmuster bekannt) ist ein Verhalten Software-Design-Muster, das einen Algorithmus der Auswahl ermöglicht bei Laufzeit