Hiểu Rõ Vòng Đời Dịch Vụ: Scoped, Transient, Singleton – Một Chặng Đường Trong Lộ Trình .NET

Scoped không có nghĩa là “một instance cho mỗi request”. Nó có nghĩa là một instance cho mỗi scope — và ASP.NET Core tạo một scope cho mỗi request chỉ vì hosting làm việc đó. Hiểu sai chỗ này là nguồn gốc của phần lớn lỗi DI trong production: DbContext bị chia sẻ giữa các request, Task.Run chạy sau khi request đã kết thúc, cấu hình không bao giờ reload, và ObjectDisposedException xuất hiện ở những chỗ không ai ngờ tới.

Cập nhật 2026

  • .NET 10 LTS (10.0.14) là bản production hiện tại; .NET 8 và .NET 9 hết hỗ trợ ngày 2026-11-10. Container DI mặc định không đổi hành vi so với .NET 8, nên các kết luận dưới đây áp dụng cho cả ba.
  • ValidateScopes và ValidateOnBuild chỉ bật mặc định ở môi trường Development. Production tắt để giảm chi phí resolve — nghĩa là captive dependency không bị chặn ở đó.
  • AddDbContextPool tái sử dụng instance DbContext; AddDbContext thì không. Cả hai đều scoped, nhưng hệ quả với state trong context khác nhau.

Scope là đơn vị, không phải request

Container có hai tầng: root sống cùng ứng dụng, và các scope con. Singleton sống ở root. Scoped sống trong một scope. Transient không có vòng đời riêng — nó được tạo ở nơi resolve và bị dispose cùng scope đã tạo ra nó, nếu nó là IDisposable.

root container
├── Singleton A           1 instance, sống đến khi app dừng
├── IOptions<T>           singleton
└── Scope (request #1)
    ├── Scoped DbContext  1 instance, dispose khi scope đóng
    ├── Transient Foo     instance riêng, dispose cùng scope
    └── Scope (con, do code của bạn tạo)

Hệ quả thứ nhất: transient không miễn nhiễm với tài nguyên. Một SqlConnection đăng ký transient trong scope vẫn bị dispose khi scope đóng, và vẫn bị tạo mới mỗi lần resolve. Hệ quả thứ hai: nếu không có scope nào được tạo, scoped và singleton trông giống nhau — đó là cái bẫy của captive dependency.

Lifetime Tạo mới khi Dispose khi
Transient Mỗi lần resolve Scope sở hữu nó đóng (hoặc root dispose nếu resolve từ root)
Scoped Lần resolve đầu trong scope Scope đóng
Singleton Lần resolve đầu trên root (hoặc lúc build nếu ValidateOnBuild) Root dispose lúc app dừng

Bốn nơi scope bắt đầu và kết thúc

1. HTTP request

Hosting tạo một scope trước khi pipeline middleware chạy và dispose nó sau khi response hoàn tất — kể cả khi handler ném exception. Scoped instance đầu tiên chỉ được tạo ở lần resolve đầu tiên trong request đó, không phải ngay khi request vào. Vì vậy một request không dùng DbContext sẽ không mở context nào.

Hệ quả thực dụng: IHttpContextAccessor.HttpContext và mọi thứ scoped khác chỉ hợp lệ bên trong scope này. Giữ một tham chiếu tới chúng trong field của singleton là giữ một object đã (hoặc sắp) bị dispose, cộng thêm HttpContext của request đầu tiên.

2. CreateScope / CreateAsyncScope

Bạn tạo scope khi cần vòng đời ngắn hơn hoặc dài hơn một request: mỗi item trong một batch, mỗi lần chạy của job nền, mỗi message trong một consumer. Scope là đơn vị công việc, không phải đơn vị thời gian.

3. Blazor: scope là circuit, không phải request

Trong Blazor Web App với render mode InteractiveServer, DI scope được tạo cho circuit — tức một phiên tương tác của một người dùng — và sống đến khi circuit đóng. Một component scoped DbContext có thể sống hàng giờ: change tracker phình dần, dữ liệu cũ vẫn nằm trong cache nội bộ, và hai component trong cùng circuit chia sẻ cùng một context. Đây là lý do phổ biến nhất khiến ứng dụng Blazor Server rò rỉ bộ nhớ.

Với WebAssembly, app chạy trong browser của một người dùng nên scoped gần như singleton. Với chế độ static SSR của Blazor Web App, mỗi request HTTP vẫn có scope riêng như MVC/Razor Pages.

4. Hosted service

BackgroundService và IHostedService được đăng ký singleton. ExecuteAsync chạy ngoài mọi request scope, nên resolve scoped service trực tiếp từ constructor sẽ ném lỗi khi bật validation, hoặc (khi tắt validation) nhận một instance sống mãi trong root scope.

Nhìn thấy vòng đời bằng một endpoint

// File: Program.cs
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddTransient<TransientProbe>();
builder.Services.AddScoped<ScopedProbe>();
builder.Services.AddSingleton<SingletonProbe>();

var app = builder.Build();

app.MapGet("/probe", (
    TransientProbe transient,
    ScopedProbe scoped,
    SingletonProbe singleton,
    IServiceScopeFactory scopes) =>
{
    using var child = scopes.CreateScope();
    var scopedInChild = child.ServiceProvider.GetRequiredService<ScopedProbe>();

    return Results.Ok(new
    {
        transient = transient.Id,            // mới mỗi lần resolve
        scoped = scoped.Id,                  // giống nhau trong cùng request
        scopedInChild = scopedInChild.Id,    // khác: scope khác
        singleton = singleton.Id             // giống nhau giữa mọi request
    });
});

app.Run();

public sealed class TransientProbe { public Guid Id { get; } = Guid.NewGuid(); }
public sealed class ScopedProbe    { public Guid Id { get; } = Guid.NewGuid(); }
public sealed class SingletonProbe { public Guid Id { get; } = Guid.NewGuid(); }

Gọi endpoint hai lần: transient đổi ở mỗi lần resolve, scoped giữ nguyên trong một lần gọi nhưng đổi giữa hai lần gọi, scopedInChild khác scoped, và singleton không đổi đến khi process restart. Nếu scoped không đổi giữa hai request, đó không phải tính năng — đó là dấu hiệu scope bị dùng sai.

Bật validation ở mọi nơi bạn kiểm soát được

builder.Host.UseDefaultServiceProvider(options =>
{
    options.ValidateScopes = true;   // chặn resolve scoped từ root
    options.ValidateOnBuild = true;  // kiểm tra toàn bộ graph lúc build
});

ValidateScopes kiểm tra lúc resolve: nó ném InvalidOperationException khi một singleton yêu cầu scoped service, hoặc khi bạn resolve scoped từ app.Services. ValidateOnBuild kiểm tra sớm hơn: khi BuildServiceProvider chạy, nó thử tạo mọi service đã đăng ký và báo lỗi thiếu dependency ngay lúc khởi động, không phải lúc request đầu tiên.

Captive dependency: lỗi tốn kém nhất

// SAI: singleton giữ một scoped service
builder.Services.AddScoped<AppDbContext>();
builder.Services.AddSingleton<ReportCache>();

public sealed class ReportCache(AppDbContext db)  // db thuộc root scope, không bao giờ dispose
{
    public Task<Report> GetAsync(Guid id, CancellationToken ct) =>
        db.Reports.AsNoTracking().FirstAsync(r => r.Id == id, ct);
}

Khi validation tắt (production), ReportCache được tạo một lần và nhận AppDbContext từ root. Context đó không bao giờ được dispose, không bao giờ được reset, và bị dùng đồng thời bởi mọi request. Triệu chứng thường gặp: InvalidOperationException: A second operation was started on this context instance before a previous operation completed, hoặc dữ liệu của người dùng A xuất hiện trong response của người dùng B vì change tracker còn giữ entity cũ.

Cách sửa đúng là đảo chiều phụ thuộc: singleton không giữ scoped service, nó giữ IServiceScopeFactory và tạo scope cho mỗi đơn vị công việc. Nếu thứ bạn cần chỉ là dữ liệu đọc và có thể cache, hãy cache kết quả (DTO đã materialize) chứ không cache DbContext.

DbContext: scoped, pool, và cái không được làm

// Mặc định: một context mới cho mỗi scope
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("Default")));

// Tái sử dụng instance giữa các request tuần tự
builder.Services.AddDbContextPool<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("Default")),
    poolSize: 128);

Cả hai đăng ký đều scoped. Khác biệt: AddDbContext tạo object mới và cấp phát model metadata mỗi scope; AddDbContextPool lấy một instance từ pool và reset nó khi trả về. Pool không chia sẻ context giữa hai request đồng thời — nó chỉ tái sử dụng instance của request trước. Vì vậy pool không sửa được captive dependency; nó chỉ giảm chi phí khởi tạo.

Điều kiện để dùng pool: context không giữ state riêng giữa các lần dùng, không giữ tham chiếu tới service khác trong field, và poolSize đủ lớn so với số request đồng thời. Nếu context có field cấu hình theo request (ví dụ tenant hiện tại), truyền nó qua tham số phương thức — hoặc bỏ pool.

  • Không đăng ký AddTransient<AppDbContext>. Mỗi lần resolve là một context mới: change tracking vỡ, transaction không bao trùm các repository call, và unit of work biến mất.
  • Không đăng ký AddSingleton<AppDbContext>. Đây là captive dependency ở dạng nguy hiểm nhất vì nó “chạy được” trong test một luồng.
  • Không resolve context từ app.Services trong startup để seed dữ liệu. Hãy tạo scope tường minh, nếu không bạn sẽ seed vào một context sống suốt vòng đời app.

Làm việc scoped trong singleton: IServiceScopeFactory

// File: Worker/OutboxPublisher.cs
public sealed class OutboxPublisher(
    IServiceScopeFactory scopeFactory,
    ILogger<OutboxPublisher> logger) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            await using var scope = scopeFactory.CreateAsyncScope();
            var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
            var publisher = scope.ServiceProvider.GetRequiredService<IOutboxPublisher>();

            try
            {
                await publisher.PublishBatchAsync(db, stoppingToken);
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "Publish batch failed");
            }

            await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);
        }
    }
}

Hai chi tiết dễ bỏ qua. Thứ nhất, scope phải nằm bên trong vòng lặp: tạo một scope ngoài while sẽ cho bạn một DbContext sống mãi, change tracker giữ mọi entity đã đọc, và bộ nhớ tăng tuyến tính. Thứ hai, dùng CreateAsyncScope với await using để dispose bất đồng bộ — DbContext có IAsyncDisposable, và dispose đồng bộ trong luồng nền có thể block.

Với IHostedService.StartAsync cũng vậy: đây là singleton, mọi dependency phải là singleton hoặc factory. Nếu cần chạy một tác vụ lúc khởi động với scoped service, tạo scope trong StartAsync và đóng nó trước khi method trả về.

IOptions và ba vòng đời khác nhau

Interface Lifetime Hành vi
IOptions<T> Singleton Đọc một lần, không bao giờ đổi trong vòng đời app
IOptionsSnapshot<T> Scoped Tính lại mỗi scope, giữ nguyên trong scope đó
IOptionsMonitor<T> Singleton Có CurrentValue và OnChange, cập nhật khi config đổi

Ba interface này là ví dụ đẹp nhất cho việc vòng đời không phải chuyện lý thuyết. Inject IOptionsSnapshot<T> vào một singleton: resolve ném lỗi ngay khi bật ValidateScopes. Inject IOptionsSnapshot<T> vào một component Blazor Server: nó chỉ đọc lại config khi circuit mới bắt đầu, tức có thể là vài giờ sau khi bạn đổi appsettings. Trong cả hai trường hợp, câu trả lời là IOptionsMonitor<T>.

Đừng lạm dụng monitor: callback của nó phải thread-safe và không được capture scoped service. Nếu config chỉ đổi khi restart, IOptions<T> rẻ hơn.

IHttpClientFactory: singleton, transient, và handler dùng chung

builder.Services.AddHttpClient<ICatalogClient, CatalogClient>(client =>
{
    client.BaseAddress = new Uri("https://catalog.internal/");
    client.Timeout = TimeSpan.FromSeconds(10);
})
.SetHandlerLifetime(TimeSpan.FromMinutes(5));

IHttpClientFactory là singleton, typed client là transient, và HttpMessageHandler được pool với lifetime mặc định 2 phút — đủ để DNS thay đổi được nhận, đủ lâu để không tạo socket mới mỗi request. Vì handler được chia sẻ, đừng để state theo request trong field của DelegatingHandler; hãy đặt header trên request, không trên handler.

Đừng tự new HttpClient() trong mỗi lần gọi (socket exhaustion và không nhận thay đổi DNS), và cũng đừng đăng ký AddSingleton<HttpClient> để “tái sử dụng”: bạn sẽ có một handler không bao giờ được rotate, cộng thêm timeout và base address dùng chung cho mọi client. Nếu muốn một client cấu hình riêng, dùng named client hoặc typed client.

Những lỗi production hay gặp

  • Scoped service dùng sau khi request kết thúc. Task.Run(async () => await repo.SaveAsync(...)) trong handler trả về response ngay; scope đóng; task chạm vào DbContext đã dispose. Nếu tác vụ phải chạy nền, đưa nó vào queue và xử lý trong hosted service có scope riêng.
  • Cache tĩnh giữ dữ liệu theo request. Một static Dictionary trong service ghi khoá theo user là bug bảo mật, không chỉ là bug bộ nhớ.
  • Scoped service giả định nó “sống một request”. Cùng class đó chạy trong Blazor circuit hoặc trong scope thủ công của job nền sẽ có vòng đời khác hẳn.
  • Transient cho thứ đắt. Một service mở connection, đọc file cấu hình lớn, hoặc giữ SemaphoreSlim mà đăng ký transient sẽ tạo N bản sao không chia sẻ gì — khoá không còn khoá.
  • Singleton không thread-safe. Mọi field mutable của singleton đều là race condition tiềm năng; dùng ConcurrentDictionary, Interlocked, hoặc chuyển state sang scoped.
  • Service locator. Inject IServiceProvider rồi GetRequiredService bên trong làm phụ thuộc vô hình, và ValidateOnBuild không thấy chúng.

Chọn lifetime: ba câu hỏi

Câu hỏi Chọn Lý do
Có state theo một đơn vị công việc không? Scoped Đơn vị công việc là request, message, batch — không phải toàn app
Không có state và chi phí tạo thấp? Transient An toàn nhất, nhưng vẫn bị dispose cùng scope
Dùng chung toàn app và phải thread-safe? Singleton Cache, factory, options, pipeline, handler

Quy tắc một dòng: nếu service cần đọc/ghi dữ liệu thay đổi theo người dùng hoặc theo đơn vị công việc, nó là scoped; nếu nó cần một scoped service khác, nó cũng phải scoped hoặc nhận factory.

2027

.NET 11 GA tháng 11/2026 (STS), .NET 12 LTS dự kiến 2027. Container DI không có thay đổi lớn trong lộ trình; điều đang thay đổi là cách viết service — keyed services (AddKeyedScoped, [FromKeyedServices]) đã ổn định từ .NET 8 và là cách sạch để có nhiều implementation cùng interface mà không cần tự chế factory. Giá trị giữ nguyên: xác định đúng đơn vị công việc.

Checklist

  • Chạy test với ValidateScopes = true và ValidateOnBuild = true; đừng chỉ dựa vào Development.
  • Không resolve scoped từ app.Services hay từ constructor của singleton.
  • Mọi singleton chỉ chứa immutable state hoặc cấu trúc thread-safe.
  • Hosted service tạo scope cho mỗi đơn vị công việc, không tạo một scope ngoài vòng lặp.
  • DbContext luôn scoped; pool chỉ khi context không giữ state riêng.
  • HttpClient đến từ factory, không phải new và không phải singleton tự tạo.

Đọc tiếp: Scrutor: quét assembly và Decorator, Tiêm phụ thuộc nâng cao khả năng kiểm thử, và Bắt đầu với EF Core Code-First.