All 15 Dependency Injection questions
More in Dependency Injection
What is dependency injection, and how does ASP.NET Core's built-in DI container support it out of the box? How do you register multiple implementations of the same interface and resolve all of them together via IEnumerable<T>? How do you use IServiceScopeFactory to manually create a DI scope outside the normal per-request pipeline, such as inside a background service? How do you register a service using a factory delegate instead of a simple type mapping, when construction requires reading configuration or resolving other services conditionally? What is the difference between constructor injection and using IServiceProvider directly to resolve dependencies imperatively (service location)? How does the Options pattern's IOptions<T>/IOptionsSnapshot<T> relate to and build upon the standard DI container? What does GetService<T>() return compared to GetRequiredService<T>() when a service isn't registered, and which should application code generally prefer? What is the 'captive dependency' problem, and how does ASP.NET Core's DI container help catch it automatically? What are keyed services (introduced in .NET 8), and what problem do they solve compared to injecting IEnumerable<T> when you need one specific implementation? How does the DI container's disposal behavior work for IDisposable services registered as Transient, and why can this cause unexpected memory retention?
Advertisement
ASP.NET Core › Dependency Injection

What is the difference between Singleton, Scoped, and Transient service lifetimes, and how does Scoped specifically map to an HTTP request?

Intermediate

Answer

Singleton creates one instance for the entire application lifetime, shared across all requests. Scoped creates one instance per client HTTP request (a new DI scope is created at the start of each request and disposed at its end), shared within that single request but distinct across different requests. Transient creates a brand-new instance every single time the service is requested, even multiple times within the same request.
builder.Services.AddSingleton<ICacheService, MemoryCacheService>();  // one instance, app lifetime
builder.Services.AddScoped<AppDbContext>();                          // one instance per HTTP request
builder.Services.AddTransient<IEmailFormatter, EmailFormatter>();    // new instance every injection
Real-world example A DbContext is registered as Scoped so all repositories within a single HTTP request share the same context (and its change tracking), while a lightweight, stateless formatter is registered as Transient since creating a new instance each time is cheap.

Common follow-ups: What happens if a Singleton service depends on a Scoped service (captive dependency problem)?;How do you choose the right lifetime for a new service?

Entity Framework Core & Data Access;Background Tasks & Hosted Services
All 15 Dependency Injection questions