Welcome to the Simple Injector project
The Simple Injector is an easy-to-use Inversion of Control library for .NET and Silverlight.
Overview
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.
Getting started
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.
}
The
UserController class depends on the
IUserRepository and
ILogger 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.Register<IUserRepository, SqlUserRepository>();
container.RegisterSingle<ILogger>(() => new CompositeLogger(
container.GetInstance<DatabaseLogger>(),
container.GetInstance<MailLogger>()
));
// 3. Optionally verify the container's configuration.
container.Verify();
// 4. Store the container for use by the MVC application.
container.RegisterAsMvcControllerFactory();
}
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 and
ILogger 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 lifestyle).
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
MailLogger 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 scenario’s.
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.
More information
For more information about the
Simple Injector please visit the following links:
Happy injecting!
This project is supported by
Simple Injector Twitter Feed