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.