Dowemo
0 0 0 0


Question:

Ok, So I have the following situation. I originally had some code like this:

public class MainBoard {
    private BoardType1 bt1;
    private BoardType2 bt2;
    private BoardType3 bt3;
    ...
    private readonly Size boardSize;
    public MainBoard(Size boardSize) {
        this.boardSize = boardSize;
        bt1 = new BoardType1(boardSize);
        bt2 = new BoardType2(boardSize);
        bt3 = new BoardType3(boardSize);
    }
}

Now, I decided to refactor that code so the classes' dependencies are injected, instead:

public class MainBoard {
    private IBoardType1 bt1;
    private IBoardType2 bt2;
    private IBoardType3 bt3;
    ...
    private Size boardSize;
    public MainBoard(Size boardSize, IBoardType1 bt1, IBoardType2 bt2, IBoardType3 bt3) {
        this.bt1 = bt1;
        this.bt2 = bt2;
        this.bt3 = bt3;
    }
}

My question is what to do about Board Size? I mean, in the first case, I just passed the class the desired board size, and it would do everything to create the other kinds of boards with the correct size. In the dependency injection case, that might not be more the case. What do you guys do in this situation? Do you put any kind of checking on the MainBoard's constructor so to make sure that the correct sizes are being passed in? Do you just assume the class' client will be responsible enough to pass the 3 kinds of boards with the same size, so there is no trouble?

Edit

Why am I doing this? Because I need to Unit-Test MainBoard. I need to be able to set the 3 sub-boards in certain states so I can test that my MainBoard is doing what I expect it to.

Thanks


Best Answer:


The main advantage of dependecy injection is the insulation from changes to the objects being injected. So in your case the one variable apparent is the size. You would inject the boards into the main board so that the main board no longer needs to know or worry about the size. Also, unless your application needs to maintain 3 distinct behaviors between the different board types I would suggest using a single abstract definition for the board type interface.

public class MainBoard {
    private IBoardType bt1;
    private IBoardType bt2;
    private IBoardType bt3;
    public MainBoard(IBoardType bt1, IBoardType bt2, IBoardType bt3) {
        this.bt1 = bt1;
        this.bt2 = bt2;
        this.bt3 = bt3;
    }
}

It becomes the responsibility of the thing that does the injection (injection framework or assembling code) to ensure these boards are given the proper size. This can be done in a number of ways one example being the main board and injected boards all derive their size from a single external source. Maybe your app, in this case, sizes the injected boards relative to the main board.

So you could have external logic such as:

public class BoardAssembler {
   public static MainBoard assembleBoard(Size size) {
      Size innerBoardSize = deriveSizeOfInternalBoards(size);
      return new MainBoard(new BoardType1(innerBoardSize), new BoardType2(innerBoardSize), new BoardType3(innerBoardSize));
   }
}

Essentially what you're after is the inversion of the construction logic wherever MainBoard is constructed. Start there and extract everything into a factory or some evil singleton factory or static method. Ask yourself, "where is the MainBoard created?" Also ask, "what compoenents and parameters are needed?" Once you've moved all the instantiation logic into a factory it may become simpler to maintain Mainboard and all of its dependencies.




Copyright © 2011 Dowemo All rights reserved.    Creative Commons   AboutUs