Why is injecting dependencies usually preferable to calling IServiceProvider.GetService inside application code?

Dependency injection versus the service locator pattern

Distinguishes explicit dependency injection from runtime service lookup and identifies the narrow framework boundaries where scoped resolution is legitimate.

1Say itAnswer out loud first

2CompareCompare with Core answer

3RefineRefine with Stronger and Advanced

TL;DR

I prefer constructor injection because the class declares what it needs, the container validates the graph, and tests can provide dependencies directly. Calling IServiceProvider from business code hides dependencies, allows optional-looking null results, and can resolve services with the wrong lifetime. It also couples the code to the container instead of to the capability it uses.

Full answer below

Practice focus

Explicit dependencies, service locator, constructors, scopes, factories, hosted services, and testability.

Answer first

Answer path

Core answer first, then checkpoints toward a stronger answer.

Start
Core answer
Start here. This is the direct spoken answer to practice first.
Why this question matters
Constructor injection makes a type's requirements visible and valid when it is created. Service location hides those requirements behind runtime lookups and moves errors away from composition.
I prefer constructor injection because the class declares what it needs, the container validates the graph, and tests can provide dependencies directly. Calling IServiceProvider from business code hides dependencies, allows optional-looking null results, and can resolve services with the wrong lifetime. It also couples the code to the container instead of to the capability it uses.
Checkpoint
Stronger answer
Optional upgrade with examples, trade-offs, and sharper phrasing.
Runtime selection does not require a general service locator. I can inject a typed factory, a dictionary of strategies, or a delegate that exposes only the intended choice. Framework-owned singleton boundaries such as hosted services may legitimately inject IServiceScopeFactory and create a scope per unit of work, but the scoped handler resolved inside that boundary should still use normal injection. The exception is explicit and local rather than spreading IServiceProvider through the application.

Review signals

Use these to catch weak phrasing, shallow reasoning, and risky claims.

Common mistakesCandidateCommon mistakesMistakes that weaken the answer or signal shallow understanding.Open details

Details

Injecting IServiceProvider for convenience.
Using GetService and accepting null for required dependencies.
Resolving a scoped service once inside a singleton.
Replacing a locator with an unbounded string-based factory.

Why is injecting dependencies usually preferable to calling IServiceProvider.GetService inside application code?

Practice focus

Answer path

Why this question matters

Review signals

Follow-up prompts

Continue practice

Go deeper

Tech stacks

Skill areas

Suggest an improvement