I've made a pretty standard console in which you type a command and it does something. However, the issue that comes to my mind is scaling: if I want to add hundreds of commands, I have to manually add a new Command instance for each one individually, which is... less than ideal.The full code is stored in this GitHub repository.Program.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;using ConsolePlus.Commands;namespace ConsolePlus{    public class Program    {        /// <summary>        /// The version of the program.        /// </summary>        public const string Version = 1.0.0.0;        public static CommandRegistry<Command> Registry = new CommandRegistry<Command>();        /// <summary>        /// The application's entry point.        /// </summary>        /// <param name=args>The command-line arguments passed to the program.</param>        public static void Main(string[] args)        {            CommandHandler.RegisterCommands();            Console.WriteLine(ConsolePlus v. + Version);            while (true)            {                Console.Write(>>> );                string line = Console.ReadLine();                List<string> parts = line.Split(' ').ToList<string>();                string commandName = parts[0];                parts.RemoveAt(0);                string[] commandArgs = parts.ToArray<string>();                try                {                    string result = Registry.Execute(commandName, commandArgs);                    if (result != null)                    {                        Console.WriteLine([{0}] {1}, commandName, result);                    }                }                catch (CommandNotFoundException)                {                    Console.WriteLine([ConsolePlus] No such command.);                }            }        }    }}CommandRegistry.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace ConsolePlus{    public class CommandRegistry<T>        where T : ICommand    {        private Dictionary<string, T> register;        public CommandRegistry()        {            register = new Dictionary<string, T>();        }        public CommandRegistry(params T[] commands)            : this()        {            foreach (T command in commands)            {                register.Add(command.Name, command);            }        }        public T GetCommand(string name)        {            if (register.ContainsKey(name))            {                return register[name];            }            else            {                throw new CommandNotFoundException(name);            }        }        public string Execute(string name, string[] args)        {            if (register.ContainsKey(name))            {                return register[name].Execute(args);            }            else            {                throw new CommandNotFoundException(name);            }        }        public void RegisterCommand(T command)        {            register.Add(command.Name, command);        }    }}ICommand.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace ConsolePlus{    public interface ICommand    {        string Name { get; set; }        string HelpText { get; set; }        bool IsPrivileged { get; set; }        string Execute(string[] args);    }}Command.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace ConsolePlus{    public class Command : ICommand    {        public string Name { get; set; }        public string HelpText { get; set; }        public bool IsPrivileged { get; set; }        private Func<string[], string> method;        public Command(string name, bool privileged, string help, Func<string[], string> commandMethod)        {            Name = name;            IsPrivileged = privileged;            HelpText = help;            method = commandMethod;        }        public string Execute(string[] args)        {            return method.Invoke(args);        }    }}CommandHandler.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace ConsolePlus.Commands{    public class CommandHandler    {        public static List<Command> AllCommands = new List<Command>        {            new Command(clear, false, ClearCommand.HelpText, ClearCommand.CommandMethod),            new Command(exit, false, ExitCommand.HelpText, ExitCommand.CommandMethod)        };        public static void RegisterCommands()        {            foreach (Command command in AllCommands)            {                Program.Registry.RegisterCommand(command);            }        }    }}And just for illustration (the other *Command classes are very similar):ClearCommand.csusing System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace ConsolePlus.Commands{    class ClearCommand    {        public static string HelpText = Clears the console screen.;        public static string CommandMethod(string[] args)        {            Console.Clear();            return null;        }    }}At the moment, to add another command, I have to create another class and add another new Command line to the CommandHandler.RegisterCommands method - not ideal. Reviews of this specifically, and if there are any better ways to do this, would be very useful - though of course, any review is a good thing.
Design patterns for console commands
c#;console
Why do you have the Command class? Why not make life much simpler for yourself by making AllCommands a List<ICommand>, and having classes like ClearCommand implement ICommand? You can then query your assembly file for classes where ICommand is implemented; that way you don't even need to fill AllCommands by hand:AllCommands = Assembly.GetExecutingAssembly().GetTypes()    .Where(x => x.GetInterfaces().Contains(typeof(ICommand))                && x.GetConstructor(Type.EmptyTypes) != null)    .Select(x => Activator.CreateInstance(x) as ICommand);Also, does AllCommands need to be called AllCommands? Can't it just be called Commands?I would also recommend to remove the setters from the properties in ICommand. That way you'd end up with something like this:public interface ICommand{    string Name { get; }    string HelpText { get; }    bool IsPrivileged { get; }    string Execute(string[] args);}public class ClearCommand : ICommand{    public string Name { get { return clear; } }    public string HelpText { get { return Clears the console screen.; } }    public bool IsPrivileged { get { return false; } }    public string Execute(string[] args)    {        Console.Clear();        return null;    }}