All 10 Dependency Injection & IoC Principles questions
More in Dependency Injection & IoC Principles
What is dependency injection, and what problem does it solve compared to a class creating its own dependencies directly? How do you register and resolve a service using ASP.NET Core's built-in dependency injection container? What is the difference between Singleton, Scoped, and Transient service lifetimes in ASP.NET Core's DI container? How does constructor injection differ from property (setter) injection, and why is constructor injection generally preferred? What causes a 'captive dependency' bug, and how does ASP.NET Core's DI container detect and prevent it? How would you implement the Factory pattern using dependency injection to resolve a specific implementation at runtime based on a parameter, when the standard container can't decide statically? How do you correctly and safely resolve a Scoped service from within a Singleton service using IServiceScopeFactory, avoiding the captive dependency problem? How would you write a custom IServiceProviderFactory or use a third-party container (like Autofac) to enable advanced DI features not supported by the built-in ASP.NET Core container, like property injection or convention-based registration? How does the DI container resolve a class with MULTIPLE constructors, and how do you influence which one gets chosen?
Advertisement
C# › Dependency Injection & IoC Principles

What is the Inversion of Control (IoC) principle, and how does dependency injection relate to it as one specific technique?

Intermediate

Answer

IoC is the broader principle that a component should NOT control the creation/lifecycle of its own dependencies — control is 'inverted' to an external source (a framework, container, or calling code). Dependency injection is ONE common technique for achieving IoC (others include the Service Locator pattern or event-driven/callback-based inversion), specifically by passing dependencies in rather than the component reaching out to fetch them.
// IoC in action: the FRAMEWORK controls when/how OrderService is created and injected,
// not OrderService's own code or its direct caller
public class OrdersController {
  public OrdersController(IOrderService orderService) { /* framework provides this */ }
}
Real-world example Understanding DI as a specific implementation of the broader IoC principle, distinguishing it from other IoC techniques like the Service Locator pattern.

Common follow-ups: Why is the Service Locator pattern generally considered an inferior alternative to constructor-based DI?

Design Patterns in C#
All 10 Dependency Injection & IoC Principles questions