Yep. I suppose your idea is generaly fine. This is being called **Command Pattern**. You might like to read more about it on Google. Used together with other well known pattern **Strategy** they both might be used here. Plus another one - **Template Method**. Let me just suggest some basic approach: public abstract class BaseCommand { protected BaseCommand() { } public void Process(StuffOptions options) { Logging.Log("here is a bunch of logging"); // here sometimes there is some action-specific code but not often ExtraStuff(); using (DocWrapper doc = new DocWrapper(options.File)) // this is in all actions { foreach (int page in doc.GetPagesToModify(options.Pages)) // this is in most actions { // call some stuff on the doc instance DoRealStuff(doc); } doc.Save(options.OutputFile); // this is in all actions } } protected abstract void DoRealStuff(DocWrapper doc); protected virtual void ExtraStuff() { } } So, now you can go and implement your commands. You have to ALWAYS implement abstract method `DoRealStuff()` but only override `ExtraStuff()` when needed. class BaseCommandA : BaseCommand { protected override void DoRealStuff(DocWrapper doc) { // Doing my stuff here! } } class BaseCommandB : BaseCommand { protected override void ExtraStuff() { base.ExtraStuff(); // I have to set some extra paramaetrs here... } protected override void DoRealStuff(DocWrapper doc) { // Doing my other stuff here! } } Then there is matter of implementing last part - **strategy**. You can keep your static switch-get approach if you like, bu t better is to hide your classes details and return commands only by their base type: public static class CommandFactory { private static BaseCommandA commandAInstance = new BaseCommandA(); private static BaseCommandB commandBInstance = new BaseCommandB(); public static BaseCommand GetCommand(invokedVerb) { switch (invokedVerb) { case "barcode": return commandAInstance; case "addblankpage": return commandBInstance; // ... } } } You might like to go into some lazy initialization inside if you like... And then - grande finale - using all this stuff: public void Processing(cmd) { CommandFactory.GetCommand(cmd.Verb).Process(cmd.Options); // ... } Ofcourse all types, and arguments are being simplified. Good luck and have nice coding. EDIT: And yes - there ofcourse are some precautions - when commands are done like that (static) all processing shall be stateless (no properties or fields inside command classes). If this is required - for example to pass some data from `DoExtraStuff()` - you just remove static fields and create new instance of command every time the `GetCommand()` is being called. Good thing is - the main Processing function remains the same - power of encapsulation. Delegate approach might also be fine, but I think my classic solution is much easier to expand, extend and maintain.