The IoC container

ServiceStack uses a slightly modified version of Funq - a very fast IoC container. Funq is also used internally for creating new service instances because of the high performance. Of course there's the possibility to use another IoC container as a dependency repository where Funq can try to access registered type which were not registered in Funq itself. So you aren't forced to use Funq as your IoC container.

So you can resolve any types from your custom IoC container except of:

• Services
• Filter attributes (are executed before a service gets called)
• Validators (validates a request DTO before the service gets called)

These are main components of ServiceStack which have very high performance requirements, so they need to be heavily cached. You'll read more about filter attributes and validators in the next documentation pages.

---

Funq has basically two ways of registering type factory functions. These functions can be anything which has the correct signature and are not limited to delegates of the form

c=> new MyType()

but could be

c => CreateAndInitialzeMyType(c.Resolve<IOne>(), c.Resolve<ITwo>)

---

The second is using the type-safe generic Register methods. There are versions for both named and un-named registrations. Both take as a parameter, a delegate which takes a Container as its single parameter and returns an instance of the type.

public IRegistration Register<TType>(Func<Container, TType> func)
public IRegistration Register<TType>(string name, Func<Container, TType>func)

---

The third method is using the type-safe generic RegisterInstance methods. There are versions for both named and un-named registrations. Both take as a parameter, an instance of the type.

public IRegistration Register<TType>(TType instance)
public IRegistration Register<TType>(string name, TType instance)

---

Use another IoC container

    public interface IContainerAdapter
    {
        T Resolve<T>();
        T TryResolve<T>();
    }

If you've registered a dependency repository (ie IContainerAdapter), the services itself are created by Funq, but the properties of the services are injected by your custom dependency repository (Windsor, Ninject, ...). So for every property on a service, the method TryResolve<T> is called. How the IContainerAdapter creates the type of the requested instance doesn't matter. Like for services, it work's the same with filter attributes and validators.

Of course custom attributes (like [Ignore] from Ninject which notify the Ninject container to not resolve the marked property) or something similar of your custom IoC container aren't noted in the services, because Funq is the one which creates a service. But for all types which are resolved by calling IContainerAdapter the behavior of your IoC container isn't changed.

So here's an example how to use Ninject side-by-side with Funq. Of course you aren't limited to the Ninect IoC container, you can use the IoC container of your choice.

    public class NinjectIocAdapter : IContainerAdapter
    {
        private readonly IKernel kernel;

        public NinjectIocAdapter(IKernel kernel)
        {
            this.kernel = kernel;
        }

        public T Resolve<T>()
        {
            return this.kernel.Get<T>();
        }

        public T TryResolve<T>()
        {
            return this.kernel.TryGet<T>();
        }
    }

Then in the AppHost Configure(Container container) method you need to enable this adapter:

//Create Ninject IoC container
IKernel kernel = new StandardKernel();
//Now register all depedencies to your custom IoC container
//...

//Register Ninject IoC container, so ServiceStack can use it
container.Adapter = new NinjectIocAdapter(kernel);