Pattern di attore in tessuto di servizio azzurro

Penso che potresti complicarlo in qualche modo.

Pensiamo alle risposte della chat come all'interfaccia utente, ogni comando è la sua "pagina web", ma invece di renderizzare html, sta restituendo risposte IRC (e talvolta canzoni, ect).

Ora torniamo indietro e facciamo riferimento al pattern MVC, quasi sempre funziona bene per un'interfaccia utente e la tua "UI" non è una delle eccezioni a mio avviso. Pensa che ogni comando ha il proprio controller, in modo simile a come in un'app web tradizionale, ogni entità avrebbe il proprio controller.

Bus
 |->Dispatcher
        |-----> SongController
        |-----> HelpController
        |-----> PollController
        |-----> ect

Sospetto che alcuni dei problemi che potresti avere provengano dal tentativo di imporre una relazione tra i comandi, dove c'è molto poco.

Tutto ciò che fa il dispatcher sopra, è capire qual è il comando, quindi inoltrare la richiesta al controller appropriato.

Avrai un progetto separato per i tuoi modelli di dominio, con classi come Utente . Un terzo progetto conterrà le classi per il salvataggio / recupero dei dati.

Il Dispatcher può anche far sì che il messaggio provenga da un bus di servizio, se lo si desidera, tuttavia, potrebbe essere eccessivo, a seconda di come sono state implementate le cose

class MessageDispatcher
{
     public void HandleMessage()
     {
          User currentUser = UserRepository.GetUser(this.GetUsername());
          Channel channel = ChannelRepository.GetChannel(this.GetChannelId())
          string commandChar = currentUser.CommandCharSetting; //usually '!', but sometimes '#'
          string command = this.ParseCommand(commandChar);
          if (command == null) //Command not found
          { 
              command = channel.DefaultCommand;
          }

          if (command == "song")
          {
              SongController.HandleMessage(currentUser, requestData);
          }
          if (command == "help")
          {
              HelpController.HandleMessage(currentUser, requestData); //Note, the method signature here CAN be different, we don't want to try to force a relationship here, where none exists. Each controller is responsible for figuring out what to do with the command itself, it may or may not need a user, which we are only passing as an optimization
          }

Successivamente il controller si prenderà cura delle specifiche del comando, inclusa la ricerca dei dati necessari dai repository, o la gestione dei bus / cose asych come l'avvio di un'attività per inviare un brano all'indirizzo appropriato.

class HelpController
{
     public void HandleMessage(user, requestData)
     {
          HelpResponseModel model = new HelpResponseModel();
          model.NumberOfPeopleHelped = StatsRepo.GetTotalPeopleHelped();
          model.CommandChar = user.CommandCharSetting;
          StatsRepo.IncrementTotalPeopleHelped();

          new HelpView().Render(model);
          //The song controller would look up the song and send the file instead
     }
 }

class HelpView : IRCView
{
    public void Render(HelpModel model)
    {
        this.WriteLine("{0} have asked for help! :)", model.NumberOfPeopleHelped);
        this.WriteLine("{0}help - get help", model.CommandChar);
        this.WriteLine("{0}poll - get opinions, model.CommandChar);
        // ect
     }
}

Il tuo controller di brani sarà molto diverso:

class SongController
{
     public HandleMessage(user, requestData)
     {
          int currentSongId = this.GetCurrentlyPlayingSongId()

          ExecuteNewTask(() =>
          {
               Song song = SongRepo.GetSong(currentSongId);
               FTPSend(this.ParseOutAddress(requestData), Song.AudioData);
          });
          new SongView().Render(); //<---- Current Song Sent :)
      }
}

Ovviamente, questo codice esatto non funzionerà per te, ma spero che tu abbia l'idea, e non cercare di complicare troppo le cose. Questo potrebbe non aver risolto i problemi di prestazioni tanto quanto avresti desiderato, ma questo design renderà più facile misurare e sostituire i dettagli secondo necessità.