Question

I frequently get the term “Dependency Injection” in a AS3 book i am reading. However, it’s has not explained what exactly it is. May anyone pls exhibit what exactly it is using some lines of AS3.0 code ?

Thanks
Vishwas

Answer 1

Dependency Injection simply means that instead of a class deciding what objects it needs in order to work it gets passed those objects from outside.

In normal development, our objects decide their classes concretely, like this:

public class MyClass
{
    private var m_someObj:SomeObj = null;

    public function MyClass()
    {
        this.m_someObj = new SomeObj;
    }
}

Moving to Dependency Injection, MyClass now gets its dependencies from external:

public class MyClass
{
    private var m_someObj:SomeObj = null;

    public function MyClass( obj:SomeObj ):void
    {
        this.m_someObj = obj;
    }
}

var myClass:MyClass = new MyClass( new SomeObj );

In that example, we pass in the SomeObj class when constructing MyClass. You can also use public variables/properties either. Passing objects through the constructor is good for vital dependencies.

Now to make this actually useful, we can use interfaces instead of concrete classes. This lets us change the behaviour of MyClass easily:

public interface ISomeObj
{
}

public class SomeObjImplA implements ISomeObj
{
}

public class SomeObjImplB implements ISomeObj
{
}

public class MyClass
{
    private var m_someObj:ISomeObj = null;

    public function MyClass( obj:ISomeObj ):void
    {
        this.m_someObj = obj;
    }
}

var myClass1:MyClass = new MyClass( new SomeObjImplA );
var myClass2:MyClass = new MyClass( new SomeObjImplB );

To give you an example, the ISomeObj interface might describe a renderer. The SomeObjImplA class will render using the normal addChild() techniques, while the SomeObjImplB class will render using blitting. Now, you can change how you render your MyClass object simply by changing a parameter – the MyClass class doesn’t need to know if it’s being rendered normally or through blitting.

The object that decides what class to pass to MyClass is what’s called an injector. How it decides which class to inject is where you get the flexibility. For example, you could load a XML object that contains the classes to inject, or use reflection, which is how Robotlegs works I think.

The link that 32bitkid posted is a pretty good explanation of the principle, but that’s the gist of it. You can also check out the wiki page. For bonus points, read about Inversion of Control, which is somewhat related.