Skip to content
Permalink
Browse files

Cleanup of README.md

  • Loading branch information...
dotnetjunkie committed May 27, 2019
1 parent af89756 commit a484ed8721177832336a2a093de27892c0ccc154
Showing with 30 additions and 32 deletions.
  1. +30 −32 README.md
@@ -8,7 +8,7 @@ _**To get a high level overview of Simple Injector, please [visit our website](h

The goal of **Simple Injector** is to provide .NET application developers with an easy, flexible, and fast **Dependency Injection library** that promotes best practice to steer developers towards the pit of success.

Many of the existing DI libraries have a big complicated legacy API or are new, immature, and lack features often required by large scale development projects. Simple Injector fills this gap by supplying a simple implementation with a carefully selected and complete set of features. File and attribute based configuration methods have been abandoned (they invariably result in brittle and maintenance heavy applications), favoring simple code based configuration instead. This is enough for most applications, requiring only that the configuration be performed at the start of the program. The core library contains many features for all your [advanced](https://simpleinjector.readthedocs.org/en/latest/advanced.html) needs.
Many of the existing DI libraries have a big complicated legacy API or are new, immature, and lack features often required by large scale development projects. Simple Injector fills this gap by supplying a simple implementation with a carefully selected, but complete set of features that allow you to write highly maintainable applications. Features like decorator registration and container-verification set it apart from the other containers. In the end, you will realize that there only two types of DI Containers—Simple Injector... and the rest.

The following platforms are supported:

@@ -24,14 +24,7 @@ The following platforms are supported:
Getting started
===============

The easiest way to get started is by installing [the available NuGet packages](https://www.nuget.org/packages?q=Author%3ASimpleInjector-Contributors&sortOrder=package-download-count) and if you're not a NuGet fan then follow these steps:

* Download the latest **runtime library** from: https://simpleinjector.org/download;
* 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;** directive on the top of the code file where you wish to configure the application.
* Look at the [Using](https://simpleinjector.readthedocs.org/en/latest/using.html) section in the documentation for how to configure and use Simple Injector.
* Look at the [More Information](https://simpleinjector.readthedocs.org/en/latest/quickstart.html#quickstart-more-information) section to learn more or if you have any questions.
The easiest way to get started is by installing [the available NuGet packages](https://www.nuget.org/packages?q=Author%3ASimpleInjector-Contributors&sortOrder=package-download-count). Take a look at the [Using](https://simpleinjector.org/using) section in the documentation on learning how to configure and use Simple Injector. Go to the [Integration](https://simpleinjector.org/integration) page to find out how to integrate Simple Injector in your favorate application framework. Look at the [More Information](https://simpleinjector.org/quickstart#quickstart-more-information) section to learn more or if you have any questions.

A Quick Example
===============
@@ -41,58 +34,64 @@ Dependency Injection

The general idea behind Simple Injector (or any DI library for that matter) is that you design your application around loosely coupled components using the [dependency injection pattern](https://en.wikipedia.org/wiki/Dependency_injection) while adhering to the [Dependency Inversion Principle](https://en.wikipedia.org/wiki/Dependency_inversion_principle). Take for instance the following `UserController` class in the context of an ASP.NET MVC application:

> **Note:** Simple Injector works for many different technologies and not just MVC. Please see the [integration](https://simpleinjector.readthedocs.org/en/latest/integration.html) for help using Simple Injector with your technology of choice.
> **Note:** Simple Injector works for many different technologies and not just MVC. Please see the [integration](https://simpleinjector.org/integration) for help using Simple Injector with your technology of choice.
``` c#
public class UserController : Controller {
public class UserController : Controller
{
private readonly IUserRepository repository;
private readonly ILogger logger;
// Use constructor injection for the dependencies
public UserController(IUserRepository repository, ILogger logger) {
public UserController(IUserRepository repository, ILogger logger)
{
this.repository = repository;
this.logger = logger;
}
// implement UserController methods here:
public ActionResult Index() {
public ActionResult Index()
{
this.logger.Log("Index called");
return View(this.repository.GetAll());
}
}
public class SqlUserRepository : IUserRepository {
public class SqlUserRepository : IUserRepository
{
private readonly ILogger logger;
// Use constructor injection for the dependencies
public SqlUserRepository(ILogger logger) {
public SqlUserRepository(ILogger logger)
{
this.logger = logger;
}
public User GetById(Guid id) {
public User GetById(Guid id)
{
this.logger.Log("Getting User " + id);
// retrieve from db.
}
}
```

The `UserController` class depends on the `IUserRepository` and `ILogger` interfaces. By not depending on concrete implementations, we can test `UserController` in isolation. But ease of testing is only one of a number of things that Dependency Injection gives us. It also enables us, for example, to design highly flexible systems that can be completely composed in one specific location (often the startup path) of the application.
The `UserController` class depends on the `IUserRepository` and `ILogger` interfaces. By not depending on concrete implementations, you can test `UserController` in isolation. But ease of testing is only one of a number of things that Dependency Injection gives you. It also enables you, for example, to design highly flexible systems that can be completely composed in one specific location (often the startup path) of the application.

Introducing Simple Injector
---------------------------

Using Simple Injector, the configuration of the application using the `UserController` and `SqlUserRepository` classes shown above, might look something like this:

``` c#
protected void Application_Start(object sender, EventArgs e) {
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>(Lifestyle.Transient);
container.Register<ILogger, MailLogger>(Lifestyle.Singleton);
container.Register<ILogger, MailLogger>(Lifestyle.Singleton);
container.Register<UserController>();
// 3. Optionally verify the container's configuration.
container.Verify();
@@ -102,14 +101,12 @@ protected void Application_Start(object sender, EventArgs e) {
}
```

> **Tip**: If you start with a MVC application, use the [NuGet Simple Injector MVC Integration Quick Start package](https://nuget.org/packages/SimpleInjector.MVC3).
> **Tip**: If you start with a MVC application, take a look at the [ASP.NET MVC integration guide](https://simpleinjector.org/mvc).
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 always create a new `SqlUserRepository` on your behalf (in DI terminology: an object with a **Transient** lifestyle).

The seconds registration maps the `ILogger` interface to a `MailLogger` implementation. This `MailLogger` is registered with the **Singleton** lifestyle; only one instance of `MailLogger` will ever be created by the `Container`.
The seconds registration maps the `ILogger` interface to a `MailLogger` implementation. This `MailLogger` is registered with the **Singleton** lifestyleonly one instance of `MailLogger` will ever be created by the `Container`.

> **Note**: 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).
Using this configuration, when a `UserController` is requested, the following object graph is constructed:

``` c#
@@ -119,23 +116,24 @@ new UserController(
logger);
```

Note that object graphs can become very deep. What you can see is that not only `UserController` contains dependencies, so does `SqlUserRepository`. In this case `SqlUserRepository` itself contains an `ILogger` dependency itself. Simple Injector will not only resolve the dependencies of `UserController` but will instead build a whole tree structure of any level deep for you.
Note that object graphs can become very deep. What you can see is that not only `UserController` contains dependencies, so does `SqlUserRepository`. In this case `SqlUserRepository` itself contains an `ILogger` dependency. Simple Injector will not only resolve the dependencies of `UserController` but will instead build a whole tree structure of any level deep for you.

And this is all it takes to start using Simple Injector. Design your classes around the SOLID principles and the dependency injection pattern (which is actually the hard part) and configure them during application initialization. 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. See the [integration guide](https://simpleinjector.readthedocs.org/en/latest/integration.html) for examples of many common frameworks.
And this is all it takes to start using Simple Injector. Design your classes around the SOLID principles and the Dependency Injection pattern (which is actually the hard part) and configure them during application initialization. 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. See the [integration guide](https://simpleinjector.org/integration) for examples of many common application frameworks.

> Please go to the [using](https://simpleinjector.readthedocs.org/en/latest/using.html) section in the [documentation](https://simpleinjector.readthedocs.org/) to see more examples.
> Please go to the [using](https://simpleinjector.org/using) section in the [documentation](https://simpleinjector.org/wiki) to see more examples.
More information
================

For more information about Simple Injector please visit the following links:

* [using](https://simpleinjector.readthedocs.org/en/latest/using.html) will guide you through the Simple Injector basics.
* The [lifetimes](https://simpleinjector.readthedocs.org/en/latest/lifetimes.html) page explains how to configure lifestyles such as *transient*, *singleton*, and many others.
* [using](https://simpleinjector.org/using) will guide you through the Simple Injector basics.
* The [Object Lifetime Management](https://simpleinjector.org/lifetimes) page explains how to configure lifestyles such as *transient*, *singleton*, and others.
* See the [Reference library](https://simpleinjector.org/ReferenceLibrary/) for the complete API documentation of the latest version.
* See the [integration guide](https://simpleinjector.readthedocs.org/en/latest/integration.html) for more information about how to integrate Simple Injector into your specific application framework.
* For more information about dependency injection in general, please visit [this page on Stackoverflow](https://stackoverflow.com/tags/dependency-injection/info).
* See the [integration guide](https://simpleinjector.org/integration) for more information about how to integrate Simple Injector into your specific application framework.
* For more information about Dependency Injection in general, please visit [this page on Stackoverflow](https://stackoverflow.com/tags/dependency-injection/info).
* If you have any questions about how to use Simple Injector or about dependency injection in general, the experts at [Stackoverflow.com](https://stackoverflow.com/questions/ask?tags=simple-injector%20ioc-container%20dependency-injection%20.net%20c%23) are waiting for you.
* For all other Simple Injector related question and discussions, such as bug reports and feature requests, the [Simple Injector discussion forum](https://simpleinjector.org/forum) will be the place to start.
* The book [Dependency Injection Principles, Practices, and Patterns](https://manning.com/seemann2) presents core DI patterns in plain C# so you’ll fully understand how DI works.

**Happy injecting!**

0 comments on commit a484ed8

Please sign in to comment.
You can’t perform that action at this time.