A simple and modular CLI application

CommandSystem.cs

/* CommandSystem.cs
 * License: NCSA Open Source
 * Author: Merijn Hendriks
 */
 
namespace App
{
    public class CommandSystem : ISystem
    {
        List<ICommand> Commands;

        public CommandSystem()
        {
            Commands = new List<ICommand>();
        }

        public void OnUpdate()
        {
            var input = Console.ReadLine().ToLower().Split(' ');
            SystemManager.Get<DisplaySystem>().ClearScreen();

            foreach (var command in Commands)
            {
                if (command.IsMatch(input))
                {
                    command.Execute(input);
                    return;
                }
            }

            Console.WriteLine($"Cannot find command {input[0]}");
        }

        public void Add<T>() where T : ICommand, new()
        {
            Commands.Add(new T());
        }
    }
}

DisplaySystem.cs

/* DisplaySystem.cs
 * License: NCSA Open Source
 * Author: Merijn Hendriks
 */
 
namespace App
{
    public class DisplaySystem : ISystem
    {
        public void OnUpdate()
        {
            // code here
        }

        public void ClearScreen()
        {
            Console.Clear();
        }
    }
}

ExitCommand.cs

/* ExitCommand.cs
 * License: NCSA Open Source
 * Author: Merijn Hendriks
 */
 
namespace App
{
    public class ExitCommand : ICommand
    {
        public bool IsMatch(string[] input)
        {
            return input[0] == "exit";
        }

        public void Execute(string[] input)
        {
            Program.executing = false;
            Console.WriteLine("Terminating game...");
        }
    }
}

HelpCommand.cs

/* HelpCommand.cs
 * License: NCSA Open Source
 * Author: Merijn Hendriks
 */
 
namespace App
{
    public class HelpCommand : ICommand
    {
        public bool IsMatch(string[] input)
        {
            return input[0] == "help";
        }

        public void Execute(string[] input)
        {
            Console.WriteLine("help: shows this menu");
            Console.WriteLine("exit: terminates game");
        }
    }
}

ICommand.cs

/* ICommand.cs
 * License: NCSA Open Source
 * Author: Merijn Hendriks
 */
 
namespace App
{
    public interface ICommand
    {
        public bool IsMatch(string[] input);
        public void Execute(string[] input);
    }
}

ISystem.cs

/* ISystem.cs
 * License: NCSA Open Source
 * Author: Merijn Hendriks
 */
 
namespace App
{
    public interface ISystem
    {
        public void OnUpdate();
    }
}

Program.cs

/* Program.cs
 * License: NCSA Open Source
 * Author: Merijn Hendriks
 */

using System;
using System.Collections.Generic;

namespace App
{
    static class Program
    {
        public static bool executing;

        static Program()
        {
            executing = true;
        }

        static void Main(string[] args)
        {
            // add systems
            SystemManager.Add<DisplaySystem>();
            SystemManager.Add<CommandSystem>();

            // add commands
            var commands = SystemManager.Get<CommandSystem>();
            commands.Add<HelpCommand>();
            commands.Add<ExitCommand>();

            // app loop
            while (executing)
            {
                SystemManager.OnUpdate();
            }
        }
    }
}

SystemManager.cs

/* SystemManager.cs
 * License: NCSA Open Source
 * Author: Merijn Hendriks
 */
 
namespace App
{
    public static class SystemManager
    {
        private static List<ISystem> Systems;

        static SystemManager()
        {
            Systems = new List<ISystem>();
        }

        public static void OnUpdate()
        {
            foreach (var system in Systems)
            {
                system.OnUpdate();
            }
        }

        public static void Add<T>() where T : ISystem, new()
        {
            Systems.Add(new T());
        }

        public static T Get<T>() where T : ISystem
        {
            foreach (var system in Systems)
            {
                if (system.GetType() == typeof(T))
                {
                    return (T)system;
                }
            }

            return default;
        }
    }
}