防止在另一个方法之前调用方法

Question

This is question is a bit broad and conceptual.

I have a class with various methods. Let's call them A and B . How can I make sure that other developers working with this class in the future will not call method B before first calling method A at least once ?

I am doing this in C++ but in general what's the best way to enforce this ? I have naive some ideas such as using a boolean variable but I would like to hear some other thoughts as well.

Answer 1

One way to guarantee this? Make it the responsibility of method B to call method A once.

Anything else is a fragile API.

Answer 2

Using a boolean is a good start, and throwing on access works OK.

However sometimes its nice to be able to enforce this at compile-time. In that case your only real option is to use some tricks.

Only expose A in your class, make it return a proxy containing B.

class MyClass {
  public:

    struct BProxy {
      public:
        MyClass * root;
        void B() { root->B(); }
      protected:
        BProxy( MyClass * self ) : root(self) {}; // Disable construction
        friend class MyClass; //So that MyClass can construct it
    };

    BProxy A() { ... return BProxy(this); }
    friend class BProxy; // So that BProxy can call B()
  protected
   void B() { ... }
};

int main() {
   MyClass m;
   BProxy bp = m.A(); 
   // m.B(); can't do this as it's private - will fail at compile time.
   bp.B(); // Can do this as we've got the proxy from our previous call to A.
}

You can also achieve something similar using protected inheritance from a baseclass implementing (or providing a virtual) B().

Answer 3

One way is to redesign your class a little differently. Consider a simple database class that needs to be initialized before being used. I'm a Java guy, so...

public class Database {
  public void init(String username, String password) // must call this first!
  public List<Object> runQuery(String sql) // ...
}

So I need to call init first. I can make a DatabaseFactory that does the initialization and returns the actual database object. We can hide the constructor so that only a DatabaseFactory can create a Database (in Java a nested class, in C++ a friend class maybe?).

public class DatabaseFactory {
   public Database init(String username, String password) // ...

   public class Database {
     private Database() {}
     public List<Object> runQuery(String sql) // ...
   }
}

So now I must go through the Factory to get to the underlying object.

DatabaseFactory factory = new DatabaseFactory();
Database database = factory.init("username", "password"); // first init (call method A)
// now I can use database (or B in your case)
database.runQuery("select * from table");

Answer 4

Have a boolean variable that determines if A has been called. Then, when someone tries to invoke B without this boolean variable being set, throw an IllegalStateException.

Or you could have B simply call A since it seems that it cannot execute without A being called first anyways.

Otherwise, and since both methods are public, there's really no other way to enforce this.

Answer 5

One way to guarantee it is that A is done in the constructor of the class. If the constructor fails (throws) then the other developers do not have anything with what to do that erroneous B with. If the constructor succeeds then A is done at least once and so B is valid operation to do.

Answer 6

I would make method "A" the constructor to initialise the object. This has to called once to use the object, enforced by the compiler. Later you can call a method "B" in the knowledge that a constructor must have been called.