Welcome to the Simple Injector project
The Simple Injector is an easy-to-use Inversion of Control library for .NET and Silverlight.
The goal of Simple Injector
is to provide .NET application developers with an inversion of control (IoC) framework that is truly easy to use, while allowing developers to replace it with a more feature-rich IoC framework when needed.
For a lot of projects, using a full blown inversion of control framework can be overkill, especially when you are not yet familiar with a particular IoC framework. The Simple Injector
solves this problem by supplying a simple implementation with a very limited set of carefully chosen features in its core library. For example, complex file- and attribute-based configuration methods have been abandoned, favoring simple code-based configuration instead. This is enough for many applications, requiring only that configuration be performed at the start of the program. In time if more advanced functionality is required, the extensibility of the Simple Injector
still allows almost any advanced scenario
or another more feature-rich IoC framework may be used instead. The Simple Injector
is designed with ease of migration in mind; the Migration Guide
helps you with moving to one of the popular frameworks.
- You will need .NET 3.5 or up to use the Simple Injector library.
- Simple Injector runs in partial trust.
- Simple Injector runs in Silverlight 3 and up (Silverlight for Windows Phone is not supported).
- There is an adapter for the Common Service Locator library.
- It is fast; blazingly fast.
If you're using NuGet
, there are NuGet packages available. Take a look here
. Otherwise, follow the steps below, to start using the Simple Injector
- Go to the Downloads tab and download the latest runtime library;
- Unpack the downloaded .zip file;
- Add the SimpleInjector.dll to your start-up project by right-clicking on a project in the Visual Studio solution explorer and selecting 'Add Reference...'.
- Add the using SimpleInjector; using directive on the top of the code file where you wish to configure the application.
- Look at the Usage section in the documentation on how to configure and use the Simple Injector.
- Look at the More information section if you want to learn more or have any questions.
A Quick Example
The general idea behind the Simple Injector
(or any DI framework for that matter) is that you design your application around loosely coupled components using the dependency injection pattern
. Take for instance the following UserController
class in the context of an ASP.NET MVC application:
Note: Simple Injector works for many different technologies, not only for MVC. Please look at the Integration Guide for help using the Simple Injector with your technology of choice.
public class UserController : Controller
private readonly IUserRepository repository;
private readonly ILogger logger;
// Use constructor injection for the dependencies
public UserService(IUserRepository rep, ILogger logger)
this.repository = rep;
this.logger = logger;
// implement UserController methods here.
class depends on the IUserRepository
interfaces. By not depending on concrete implementations, we can test UserController
in isolation. Ease of testing is however, just the start of what Dependency Injection will accomplish. It allows us to design highly flexible systems that can completely be composed at a single place (often the startup path) in the application.
Using the Simple Injector
, the configuration of the application using the UserController
class, could look as follows:
protected void Application_Start(object sender, EventArgs e)
// 1. Create a new Simple Injector container
var container = new Container();
// 2. Configure the container (register)
container.RegisterSingle<ILogger>(() => new CompositeLogger(
// 3. Optionally verify the container's configuration.
// 4. Store the container for use by the MVC application.
Note: The example makes use of the extension method for ASP.NET MVC from the MVC Integration wiki page, which is also available as NuGet Simple Injector MVC3 Integration package.
The given configuration registers implementations for the IUserRepository
interfaces. The code snippet shows a few interesting things. First of all, you can map concrete instances (such as SqlUserRepository
) to an interface or base type. In the given example, every time you ask the container for an IUserRepository
, it will create a new SqlUserRepository
on your behalf (in DI terminology: an object with a transient
The registration of the ILogger
is a bit more complex though. It registers a delegate that knows how to create a new ILogger
implementation, in this case CompositeLogger
(which is an implementation of ILogger
). The delegate itself calls back into the container and this allows the container to create the concrete DatabaseLogger
and inject them into the CompositeLogger
. While the type of registration that we’ve seen with the IUserRepository
is much more common, the use of delegates allows many interesting scenarios.
Note that we did not register the UserController. Because the UserController is a concrete type, Simple Injector can implicitly create it (as long as its dependencies can be resolved).
This is in fact all it takes to start using the Simple Injector
. Design your classes around the dependency injection principle and configure them in the top of your application. Some frameworks (such as ASP.NET MVC) will do the rest for you. Other frameworks (like ASP.NET Web Forms) will need a little bit more work to get this done. See the Integration Guide
for examples of your framework of choice.
Please go to the Using the Simple Injector section in the documentation to see more examples.
For more information about the Simple Injector
please visit the following links:
This project is supported by
Simple Injector Twitter Feed