Dependency Injection - Is it better to pass a complete class, or the name of a class?

Question

For dependency injection, I understand that I have to pass an instance of one class to the main instance instead of the main class creating it's own instance, like so (php):

class Class_One {
  protected $_other;
  public function setOtherClass( An_Interface $other_class ) {
    $this->_other_class = $other_class;
  }
  public function doWhateverYouHaveToDoWithTheOtherClass() {
    $this->_other_class->doYourThing();
  }
}

interface An_Interface {
  public function doYourThing();
}

class Class_Two implements An_Interface {
    public function doYourThing() { }
}

class Class_Three implements An_Interface {
    public function doYourThing() { }
}


// Implementation:
$class_one = new Class_One();
$class_two = new Class_Two();
$class_three = new Class_Three();
$class_one->setOtherClass( $class_two );
$class_one->doWhateverYouHaveToDoWithTheOtherClass();
$class_one->setOtherClass( $class_three );
$class_one->doWhateverYouHaveToDoWithTheOtherClass();

This is all fine. I know that since both Class_Two and Class_Three both implement An_Interface, they can be used interchangeably in Class_One. Class_One wouldn't know the difference between them.

My question is, is it ever a good idea to, instead of passing an instance to setOtherClass, pass a string such as "Class_Two", and have Class_One's setOtherClass method actually create the instance itself like so:

class Class_One {
  ...
  public function setOtherClass( $other_class_name ) {
    $this->_other_class = new $other_class_name();
  }
  ...
}

Does this sort of defeat the purpose of Dependency Injection, or is this completely valid? I thought this type of set up may help me with configuration, where a user can specify which class he wants to use in a string earlier on and this can later be passed to the Class_One..

Actually, writing this out has made me think that it's probably not a good solution, but I'll still post this in case someone can give me some good feedback on why I should/shouldn't do this.

Thanks =)

Ryan

If you pass a string you're not really passing the dependency. If the class you're passing doesn't have any dependencies itself then it's a leaf so you don't need to pass it in anyway. — rojoca, Feb 16 '11 at 18:21

score 5 · Accepted Answer · answered Feb 16 '11 at 18:23

That theoretically defeats the purpose of dependency injection; you are telling Class_One, which depends on An_Interface, which concrete implementation of that interface it should instantiate. That requires Class_One to know how to instantiate ANY An_Interface implementation, tightly coupling Class_One to ALL An_Interface implementations. If you add a new An_Interface Class_Four, you have to go back and tell Class_One how to instantiate a Class_Four.

In PHP, you get away with this AS LONG AS all An_Interface implementations have a parameterless constructor. However, if any implementation needs OTHER dependencies injected, you're screwed; you can't tell Class_One to just new up a Class_Four if a Class_Four needs a Class_Five that Class_One doesn't know about.

Thanks, I think this explains it quite clearly. I was thinking the same thing about it working only when the constructor had no parameters, so I think it all makes sense. — manbeardpig, Feb 17 '11 at 07:52

score 3 · Answer 2 · answered Feb 16 '11 at 18:20

3

Pass an object that's specified by an interface. Otherwise how will you always know with 100% accuracy what it will take to construct the object?

public function __construct(MyInterface $object) {
}

That way, it doesn't matter how you create the object, you just need to know if you can use it how you need to (the interface you're programming against)...

answered Feb 16 '11 at 18:20

ircmaxell

163,128
34
264
314

Couldn't I use $object=new $object_name(); if($object instanceof MyInterface){} etc, in that __construct() method? It's much messier of course, but it is pretty much the same, right? (and can fail more cleanly since I choose what to do if it fails) – manbeardpig Feb 16 '11 at 18:32
@manbeardpig: It's not the same. You're changing the interface of your object. With using the typehint, you're telling the rest of the program in no ambiguous terms *Hey, I need an instance of MyInterface as my first parameter*. If you use the string, the requirement isn't shared at all. You'd need to document it, and then either read the docs or read the source code to figure out what it needs (both of which break encapsulation). Declare the requirements in the interface, since it's easier and clearer... – ircmaxell Feb 16 '11 at 18:37

score 0 · Answer 3 · answered Feb 16 '11 at 18:22

Either way is technically equivalent IMO. The main test to tell if you are doing dependency injection right is to see if you are using any constant strings with "new" or with static method calls. Your code looks good, as long as in the implementation section, the classes can be changed via configuration or some other mechanism. The only downside with passing a string name of a class is that you can't be sure that it implements an specific interface or extends some other object. The checking for this could get messy. However, if your application can handle this issue gracefully, then you should be alright. Passing an actual instantiated object though is the best technique.

Dependency Injection - Is it better to pass a complete class, or the name of a class?

3 Answers3