Styjun

I'll clarify my question by first describing my use case:

I am writing an IMAP server, which receives commands from clients. If it is in the right state to do so, it reads a token from the network socket, and interprets that token as a command's name. As of right now, my server reads the command's name from the token and uses a switch statement to execute the corresponding code.

Here's a glimpse of it:

case ("CAPABILITY"): this.executeCapability(tag); break;
case ("NOOP"): this.executeNoop(tag); break;
case ("LOGOUT"): this.executeLogout(tag); break;
case ("LOGIN"): this.executeLogin(tag, args); break;

My question is: is there an objectively preferable reason to use events to dispatch commands instead? Would performance be better? Is there a security advantage?

My proposed alternative might look something like this:

server.on("CAPABILITY", executeCapability);
server.on("NOOP", executeNoop);
server.on("LOGOUT", executeLogout);
server.on("LOGIN", executeLogin);

Events are more easily extensible and usable by other code. They live in a system where the infrastructure already exists for anyone else to listen for any of those events. If you're calling a function, passing an argument and then using a switch statement to dispatch, then that's a custom, non-standard interface and if someone else (even another part of your own code) wants to listen for one of those events and act on it themselves, then they have to build some of their own custom code to somehow do that.

If you use events, then that infrastructure is already there. They can just listen for the event with their own listener.

Here's a little example. Imagine that for performance reasons you are caching some data from the database for each user. When the user logs out, you'd like to clear the cache. Your cache system is its own module because it can be reused in other apps. If you use events, the cache can just set its own event listener for the logout event and can do its own housekeeping when a given user logs out. In the switch design, you'd probably have to insert code in the executeLogout() function to call some method in the cache. That would work, but the code wouldn't be as encapsulated as it could be. Now, you have cache logic in the logout() method where you wouldn't need that with the event system because the cache can just watch for the events its interested in all on its own.

I'm not saying this is a killer example that means you have to do it one way or the other. Just showing some architectural advantages of events where it allows sub-systems easier access to the events so they can manage themselves (more encapsulated code) more easily.

I don't think there would be a meaningful performance difference. If you were in a tight performance sensitive loop, the event subsystem probably introduces a few more function calls to dispatch vs. the switch statement, but for regular code this wouldn't be consequential.