Пишем Skype бота на C# с модульной архитектурой

class Program
    {
        //инициализируем объект класса Skype, с ним в дальнейшем и будем работать
        private static Skype skype = new Skype();        

        static void Main(string[] args)
        {
            //создаём тред, дабы не лочить нашу консольку
            Task.Run(delegate
            {
                try
                {
                    //подписываемся на новые сообщения
                    skype.MessageStatus += OnMessageReceived;
                    //пытаемся присоединиться к скайпу. В данный момент вылезет окошко, где он у вас спросит разрешения на открытие доступа программе.
                    //5 это версия протокола (идёт по-умолчанию), true - отключить ли отваливание по таймауту для запроса к скайпу.
                    skype.Attach(5, true);
                    Console.WriteLine("skype attached");
                }
                catch (Exception ex)
                {
                    //выводим в консольку, если что-то не так
                    Console.WriteLine("top lvl exception : " + ex.ToString());
                }
                //варварски фризим поток
                while (true)
                {
                    Thread.Sleep(1000);
                }
            });
            //варварски фризим основной поток
            while (true)
            {
                Thread.Sleep(1000);
            }
        }
        
        //обработчик новых сообщений
        private static void OnMessageReceived(ChatMessage pMessage, TChatMessageStatus status)
        {
            //суть такова, что для каждого сообщения меняется несколько статусов, поэтому мы ловим только те, у которых статус cmsReceived + это не позволит в будущем реагировать нашему боту на свои же сообщения
            if (status == TChatMessageStatus.cmsReceived)
            {
                Console.WriteLine(pMessage.Body);
            }
        }  
    }

public interface IActionHandler
    {
    
        List <string> CallCommandList { get;}
      
        string CommandDescription { get; }
      
        void HandleMessage(string args, object clientData, Action<string> sendMessageFunc);
    }

public interface IActionHandlerRegister
    {
        List<IActionHandler> GetHandlers();
    }

public interface ISkypeData
    {
       string FromName { get; set; }
    }

public class Say : IActionHandler
    {
        private Random r = new Random();
        private List<string> answers = new List<string>()
        {
            "Вот сам и скажи",           
            "Ищи дурака",
            "Зачем?",
            "5$",
            "Нет, спасибо",
        };

        public List<string> CallCommandList
        {
            get { return new List<string>() { "скажи", "say" }; }
        }
        public string CommandDescription { get { return @"Говорит что прикажете"; } }
        public void HandleMessage(string args, object clientData, Action<string> sendMessageFunc)
        {
            if (args.StartsWith("/"))
            {
                sendMessageFunc(answers[r.Next(0,answers.Count-1)]);
            }
           else
            {
                sendMessageFunc(args);
            }
        }
    }

 public class HelloBot
    {
        private  List<IActionHandler> handlers = new List<IActionHandler>();
        //за Tuple автора не пинать, ему как и вам хочется прокрастинировать, а не писать спецклассы
        private IDictionary<string, Tuple<string, Func<string>>> systemCommands;
        private string dllMask { get; set; }
        private string botCommandPrefix;
        private int commandTimeoutSec;

        public HelloBot(string dllMask = "*.dll", string botCommandPrefix = "!")
        {
            this.dllMask = dllMask;
            this.botCommandPrefix = botCommandPrefix;
            this.commandTimeoutSec = 60;

            systemCommands = new Dictionary<string, Tuple<string, Func<string>>>()
            {
                {"help", new Tuple<string, Func<string>>("список системных команд", GetSystemCommands)},
                {"modules", new Tuple<string, Func<string>>("список кастомных модулей", GetUserDefinedCommands)},
            };
            RegisterModules();
        }

        private void RegisterModules()
        {
            handlers = GetHandlers();
        }

        protected virtual List<IActionHandler> GetHandlers()
        {
            List<IActionHandler> toReturn = new List<IActionHandler>();
            var dlls = Directory.GetFiles(".", dllMask);
            var i = typeof(IActionHandlerRegister);
            foreach (var dll in dlls)
            {
                var ass = Assembly.LoadFile(Environment.CurrentDirectory + dll);

                //get types from assembly
                var typesInAssembly = ass.GetTypes().Where(x => i.IsAssignableFrom(x)).ToList();

                foreach (Type type in typesInAssembly)
                {
                    object obj = Activator.CreateInstance(type);
                    var clientHandlers = ((IActionHandlerRegister)obj).GetHandlers();
                    foreach (IActionHandler handler in clientHandlers)
                    {
                        if (handler.CallCommandList.Any())
                        {
                            toReturn.Add(handler);
                        }
                    }
                }
            }

            return toReturn;
        }

        public void HandleMessage(string incomingMessage, Action<string> answerCallback, object data)
        {
            if (incomingMessage.StartsWith(botCommandPrefix))
            {
                incomingMessage = incomingMessage.Substring(botCommandPrefix.Length);
                var argsSpl = incomingMessage.Split(' ');

                var command = argsSpl[0];

                var systemCommandList = systemCommands.Where(x => x.Key.ToLower() == command.ToLower()).ToList();
                if (systemCommandList.Any())
                {
                    var systemComand = systemCommandList.First();
                    answerCallback(systemComand.Value.Item2());
                }
                else
                {

                    var foundHandlers = FindHandler(command);
                    foreach (IActionHandler handler in foundHandlers)
                    {
                        string args = incomingMessage.Substring((command).Length).Trim();
                        IActionHandler hnd = handler;
                        var cts = new CancellationTokenSource(TimeSpan.FromSeconds(commandTimeoutSec));
                        var token = cts.Token;
                        
                        Task.Run(() =>
                        {
                            using (cts.Token.Register(Thread.CurrentThread.Abort))
                            {
                                try
                                {
                                    hnd.HandleMessage(args, data, answerCallback);
                                }
                                catch (Exception ex)
                                {
                                    if (OnErrorOccured != null)
                                    {
                                        OnErrorOccured(ex);
                                    }
                                    answerCallback(command + " пал смертью храбрых :(");
                                }
                            }
                            
                        },token);

                    }
                }
            }
        }

        public delegate void onErrorOccuredDelegate(Exception ex);
        public event onErrorOccuredDelegate OnErrorOccured;

        private List<IActionHandler> FindHandler(string command)
        {
            return handlers.Where(x => x.CallCommandList.Any(y=>y.Equals(command, StringComparison.OrdinalIgnoreCase))).ToList();
        }

        private string GetSystemCommands()
        {
            return String.Join(Environment.NewLine, systemCommands.Select(x => String.Format("!{0} - {1}", x.Key, x.Value.Item1)).ToList());
        }

        private string GetUserDefinedCommands()
        {
            return String.Join(Environment.NewLine, handlers.Select(x => String.Format("{0} - {1}", string.Join(" / ", x.CallCommandList.Select(y => botCommandPrefix + y)), x.CommandDescription)).ToList());
        }
    }

class Program
    {
        private static Skype skype = new Skype();
        //объявляем нашего бота
        private static HelloBot bot;

        static void Main(string[] args)
        {
            bot = new HelloBot();
            //подписываемся на событие ошибки, если таковая случится
            bot.OnErrorOccured += BotOnErrorOccured;
            Task.Run(delegate
            {
                try
                {
                    skype.MessageStatus += OnMessageReceived;
                    
                    skype.Attach(5, true);
                    Console.WriteLine("skype attached");
                }
                catch (Exception ex)
                {
                    Console.WriteLine("top lvl exception : " + ex.ToString());
                }
                while (true)
                {
                    Thread.Sleep(1000);
                }
            });
            
            while (true)
            {
                Thread.Sleep(1000);
            }
        }

        static void BotOnErrorOccured(Exception ex)
        {
            Console.WriteLine(ex.ToString());
        }

        private static void OnMessageReceived(ChatMessage pMessage, TChatMessageStatus status)
        {
            Console.WriteLine(status + pMessage.Body);
 
            if (status == TChatMessageStatus.cmsReceived)
            {
                //отсылаем сообщения на обработку боту и указываем в качестве ответного коллбека функцию SendMessage, проксируя туда чат, откуда пришло собщение
                bot.HandleMessage(pMessage.Body, answer => SendMessage(answer,pMessage.Chat),
                    new SkypeData(){FromName = pMessage.FromDisplayName});
            }
        }
        

        public static object _lock = new object();
        private static void SendMessage(string message, Chat toChat)
        {
                //во избежании конкурентных вызовов скайпа ставим все приходящие сообщения в очередь посредством lock'а
                lock (_lock)
                {
                    //отвечаем в чат, из которого пришло сообщение. Профит!
                    toChat.SendMessage(message);
                }
        }
    }