Question

From my understanding, prism’s unity container can resolve types event if they have not been registered, does this make _container.RegisterType kinda useless ?

Thanks!

Answer 1

If I am understanding your question correctly, what you are seeing is that Unity can (try to) make instances of classes directly, which is different from resolving types. It is perfectly reasonable to ask Unity to create a class “directly”, however, in order to leverage “Inversion of Control”, you would normally ask a container to resolve an interface, where you have mapped an interface to a class via RegisterType. This way you can map different implementations of classes to interfaces, without having to change your code, that is “Inversion of Control” and “Interfaced-based Programming” at work.

This process involves you asking to resolve an interface, followed by Prism finding what is bound to the interface i.e. resolution, and then making an instance for you i.e. factory capabilities. The factory capabilities of Unity will ensure that any other dependencies are resolved that are required to make an instance of the resolved class e.g. using dependency injection on class constructor parameters. This whole process is recursive until all dependencies are resolved.

For Example

If you ask for an IFoo and it is bound Foo, Unity will try and make an instance of Foo. If Foo has a constructor which takes an IBar, Unity will try and resolve IBar and create an instance of this to use in the constructor for IFoo.

So in the following code:

We can resolve IFoo as described above.

We can make an instance of class Bar directly, as it has no dependencies.

We can make an instance of class Foo directly, as it has a dependency on IFoo, but we have registered it.

We cannot make an instance of Woo directly as there is no registration for IYay.

//Types
public interface IBar{}
public class Bar : IBar {}

public interface IFoo{}
public class Foo : IFoo{ public Foo(IBar bar) {} }

public interface IYay{}
public class Woo { Woo(IYay yay){} }

//Registrations
container.RegisterType<IFoo, Foo>();
container.RegisterType<IBar, Bar>();

//Resolve IFoo
IFoo foo = container.Resolve<IFoo>();

//Create Bar directly
Bar bar = container.Resolve<Bar>();

//Create Foo directly
Foo foo = container.Resolve<Foo>();

//Create Woo directly - won't work as IYay is not registered!
Yay yay = container.Reolve<Yay>();

In the example above RegisterType is used to map a concrete implementation to an interface. It is at this point that we can map any implementation we want and this will ripple throughout our program as long as the container is always used to resolve types.

For example, if we change what IBar is mapped to, then any time IFoo is resolved it will be created with that different implementation of IBar. This gives us a substantial way of altering a program’s behaviour by just changing a single line of code i.e. RegisterType.