Initalizing an object from an Interface instead of concrete class

What you see is the very heart of interfaces and almost the very heart of OOP (the real hart of which is late binding using virtual). Understanding such things is one of prerequisites to understanding of the very basics of OOP.

For a minute, forget that IUnityContainer is interface, let's just talk in terms of some types which allow inheritance. Is there anything unusual to you?
The type in declaration IUnityContainer on left is a compile-time type; the type of constructor on right defines run-time type class. Do you know why we need different compile-time and run-time classes? Ever heard of abstraction? Hiding of excessive detail? Even though we ignore the fact one of those types is interface, we can consider a compile-time type as an abstract interface to a set of different possible concrete classes. When as work with the variable container, we don't need anything that makes different concrete classes different, we want to work with abstract interface. The type UnityContainer is derived from the type IUnityContainer; it makes the variable container assignable to the value on the right of "=".

I was talking only about types above, not mentioning classes or interfaces. We only needed to idea of inheritance. Additionally, in classes, the modification of behavior of the concrete classes is supported by virtual methods (and properties) and late binding.

Now, adding the notion of interface to the picture. In our context, consider using interface as an additional constraint to our compile-time type. A base class could be non-abstract and could be instantiated, but interface is always abstract. A base class could have data, but interface cannot. The idea is that concrete implementation is only defined at the moment of construction, and all the usage of objects is done via interface references only.

Interfaces can one more distinct feature related to polymorphism. The mechanism of virtual methods is only applicable to classes, which are reference type. Is the polymorphism possible with value types? Yes, but this fact is not very well known by many developers. The thing is: interfaces could be implemented even by structures (struct). So, the polymorphism using interfaces for abstract types can go so far that it can be agnostic not only about concrete implementing types, but even about the knowledge what types are the reference types and what are the value types.

Also, multiple inheritance is possible with interfaces but not classes. More exactly, an interface can have unlimited number of base interfaces; and a class can have only one base class but unlimited number of base interfaces in inheritance list. This is called weak form of multiple inheritance.

I would say, it you have problem understanding of anything from what I mentioned above, you will need to start learning OOP from the very beginning. It's very useful anyway; if you do it well, the time and effort will pay off pretty soon.

—SA