c# - Designing and Implementing an API that does several steps -

what can best design approach? requirement create simple service interface 20-30 different steps. in other words, have service class function dosomework(). , dosomework going perform 20-30 steps , if successful return success message , if failed return exact message of failed , why.

public class somework :isomeworkwork{ public statusmessage dosomework(){    //do step 1    //do step 2    //do step 3  } } 

the simplest way encapsulate steps inside private methods , call them inside dosomework() method. not acceptable, since individual steps wont testable, mock-able. other way create separate class that'll implment interface isomeworkservice. inside dosomework method instance of isomeworkservice, through ioc container , invoke methods steps. thinking if state pattern fits scenario or not. need dosomework should able figure out automatically, step need execute , should either run till last step or exit if error encountered. appreciable :)

i'm semi-reluctant suggest since 20 steps lot contend (and in fact might worth while trying this), things messy, but...

one approach take have kind of delegate mechanism, allow caller break flow of code , override default logic within step. achieve same effect using events, although think delegates may cleaner.

this allow caller (which unit test rig) mock individual step. or not.

so, dosomework() still contain logic says, step 1, step 2, step 3 etc. steps can (but don't have be) overridden caller.

as say, if you're talking several tens of steps become quite messy, more think reckon whatever approach take allows mock many steps, going quite messy.

for example (assuming you're processing widgets, , using delegates):

your "worker" class follows:

public delegate widget steponeactiondelegate(widget widget);  public class worker {      public steponeactiondelegate steponeaction { get; set; }      public worker()     {         steponeaction = realstepone;     }      public void dosomework()     {         widget widget = new widget();         widget newwidget = steponeaction(widget);         // more steps here     }      private widget realstepone(widget widget)     {         // real work here         return widget;     } } 

...while test harness like...

    void test()     {         worker worker = new worker();         worker.steponeaction = newstepone;         worker.dosomework();     }       widget newstepone(widget widget)     {         // mocking here         return widget;     } 

...and in "real life" you'd say....

    void doitforreal()     {         worker worker = new worker();         worker.dowork();     } 

this approach allow mock each step individually if wish, preserve structure/functionality of worker class develop it. allow create more specialized workers going forward, example buy of steps of original worker class, own thing in steps 5, 9 , 14.