A design pattern to reduce coupling between components, by dynamically injecting into a software component dependencies that it needs to function.

- Stackoverflow.com Wiki
17 articles, 2 books. Go to books ↓

So what about inversion of control containers? There's a lot of confusion around what they do, and why you should use one at all.

This post will show you how to modify the default MVC 5 template, so that it uses Autofac to inject the ASP.NET Identity dependencies into the Account Controller.

ASP.NET 5 has dependency injection available at framework level and ASP.NET 5 makes heavy use of it. Most of things surrounding controllers, views and other MVC components are implemented as services that web applications consume.

ASP.NET MVC 6 comes with a basic dependency injection container that will allow you to implement constructor and property dependency injection into your controller classes. This may be enough for smaller ASP.NET MVC 6 applications while other applications can continue to use Autofac, Ninject, StructureMap, Unity, etc.

Swinject is a lightweight dependency injection framework written in Swift to use with Swift. The framework APIs are easy to learn and use because of the generic type and first class function features of Swift.

Learn about the past, present and future of dependency inversion in JavaScript

Dependency Injection's primary purpose is to separate the implementation from the interface, and allow the system to supply the implementation at a given time. StructureMap (and it's Web API implementation) provide most of the groundwork to do just that.

ASP.NET Core 1.0 is a complete rewrite of ASP.NET, and one of the main goals for this new framework is a more modular design. That is, apps should be able to leverage only those parts of the framework they need, with the framework providing dependencies as they’re requested.

Lets look at some of the default dependency injection in ASP.NET Core to see how it is supposed to work.

This blog post explains how to use other containers with ASP.NET Core and shows how to use Structuremap and Autofac with framework level dependency injection.

Dependency injection is an important application design pattern. Angular has its own dependency injection framework, and you really can’t build an Angular application without it.

"Dependency Injection" is a 25-dollar term for a 5-cent concept. That's not to say that it's a bad term... and it's a good tool. But the top articles on Google focus on bells and whistles at the expense of the basic concept.

Is an IoC container or dependency injection framework a good thing or not? Well, I think that is a stupid question. Any tool has its merits. Just use it with responsibility. But do you need it?

The idea is quite simple – instead of injecting all of your dependencies via the controller’s constructor, you can inject them as parameters into the action handling a given HTTP request. This can help you prevent over-injection in the constructor.

The Twilio C# helper libraries are largely static, so you don't have to use DI, but sometimes you might want to. For example, you might want to create a custom TwilioRestClient that uses the HttpClientFactory features of .NET Core 2.1. In this post, I describe how to create a custom ITwilioRestClient, register it with the ASP.NET Core DI container, and inject it into a web API controller, so you can use it to send an SMS.

ASP.NET Core uses built-in dependency injection mechanism provided by Microsoft. This blog post intorduces how to use same mechanism in .NET Core console applications. For those who like other DI/IoC frameworks this writing provides demo about how to use Autofac with .NET Core framework-level dependency injection.