CODEWITHSUNDEEP
c#design-patterns
Christian Phillips
Christian Phillips

Reputation: 18759

Force object to run/execute methods in sequence

I have a class which takes multiple collections, and then needs to perform calculations on these collections in a particular order. E.G.

public class ClassCalc
    {
        public ClassCalc(double varEm, 
                          List<List<double>> col1, 
                          List<List<double>> col2)
        {
          //set fields etc.
        }

        public void CalcCols(){
           //here, I will 'zip' col1/col2 to create List<double> for each
        }

        public void CalcStep2(){
           //this is dependent on the results from CalcCols()
        }

        public void CalcNonDependent(){
           //this can be called at any stage
        }
}

The constructor forces the client to supply the relevant data, so there's an obvious ways to do this, by calling the methods in the constructor, this way, I know that everything will be populated. But, this doesn't seem like a clean solution, especially when I want to unit test parts of the code.

If I want to unit test CalcNonDependent(), I need to fully initialize the object, when I might not even require the result of the other two calculations.

So, my question, is there a pattern that can be used for this particular scenario; I have looked at Chain of Responsibility & Command Pattern, but wondered if anyone has any suggestions

Upvotes: 2

Views: 1674

Answers (5)

Kjartan
Kjartan

Reputation: 19101

You might want to extract an interface for your public operation, and expose only a single public method through it.

Using this in conjunction with e.g. P.Brian.Mackey's answer will make the other methods invisible from a clients perspective, while they can still be public in the implementing class, thus allowing for unit testing if needed.

Upvotes: 0

P.Brian.Mackey
P.Brian.Mackey

Reputation: 44275

I recommend concentrating on code coverage rather than method coverage. This way you can make the methods private and expose a single method that calls all 3 methods providing 100% coverage for the class. If you are concerned with dividing the tests for performance reasons then you can further subdivide the tests into groups which perform nightly long running tests vs daily/with every checkin tests.

The command pattern isn't going to solve much in the way of making the class more test-able. I would use such a pattern if you needed runtime workflow adaptation (E.G. M1(), M2(), then M2(), M1(), then M2(), M3() etc).

For example,

public class ClassCalc
    {
        public ClassCalc(double varEm, 
                          List<List<double>> col1, 
                          List<List<double>> col2)
        {
          //set fields etc.
        }

        public void DoWork()
        {
             //Run methods in order.
        }

        private void CalcCols(){
           //here, I will 'zip' col1/col2 to create List<double> for each
        }

        private void CalcStep2(){
           //this is dependent on the results from CalcCols()
        }

        private void CalcNonDependent(){
           //this can be called at any stage
        }
}

Upvotes: 4

oerkelens
oerkelens

Reputation: 5161

If for CalcStep2 it is necessary that CalcCols has been executed, why not keep a flag to keep track of it, and include in CalcStep2 something like

if (!CalcColsHasBeenDone)
  CalcCols();

Of course, don't forget to set CalcColsHasBeenDone to true at the end of CalcCols :)

Upvotes: 1

Ben
Ben

Reputation: 1963

Have you looked at Template? Not sure if it applies to your situation 100% but you would have a base class which defines 3 abstract methods and then calls them in the correct order.

class SomeBaseClass
{
    public abstract void CalcCols();

        public abstract void CalcStep2();

        public abstract void CalcNonDependent();

    public void DoAllCalculations() 
    {
        CalcCols();
        CalcStep2();
        CalcNonDependent();
    }
}

Then you inherit from this class and provide concrete implementations of your calculation methods.

Upvotes: 8

David Arno
David Arno

Reputation: 43254

You seem to be making a complicated problem out of nothing. Just change the class to:

public class ClassCalc
{
    public ClassCalc(double varEm, 
                     List<List<double>> col1, 
                     List<List<double>> col2)
    {
        //set fields etc.
    }

    public void CalcCols()
    {
       //here, I will 'zip' col1/col2 to create List<double> for each
       CalcStep2();
    }

    public void CalcNonDependent()
    {
       //this can be called at any stage
    }

    private void CalcStep2()
    {
    }
}

Upvotes: 1

Related Questions