C# Academy · leksjon

Tjenestelevetider: Transient, Scoped, Singleton

Lær hvordan levetidene Transient, Scoped og Singleton påvirker opprettelse, deling og frigjøring av objekter.

Leksjon 2 av 413 trinn

Tjenestelevetider: Transient, Scoped, Singleton er en gratis leksjon i C# Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i C# Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i C# Academy inneholder totalt 4 leksjoner.

Hvorfor levetider er viktige

Tjenestens levetid styrer hvor lenge en instans lever og hvor mange instanser som opprettes. Feil levetid kan føre til vanskelige feil, for eksempel datalekkasjer mellom forespørsler eller unødvendig mange objekter.

Transient: Ny hver gang

Transient-tjenester opprettes på nytt hver gang de hentes fra containeren. Bruk dem for lette, tilstandsløse tjenester der deling av tilstand kan være risikabelt.

builder.Services.AddTransient<IEmailSender, SmtpEmailSender>();

// Each resolution creates a new instance:
// var a = sp.GetRequiredService<IEmailSender>(); // new
// var b = sp.GetRequiredService<IEmailSender>(); // new (different)

Scoped: Én per forespørsel

Scoped-tjenester opprettes én gang per scope – vanligvis én HTTP-forespørsel i ASP.NET Core. Den samme instansen deles innenfor én forespørsel, men en ny instans opprettes for neste forespørsel.

builder.Services.AddScoped<AppDbContext>();

// Within a single HTTP request:
// Both resolve to the SAME AppDbContext instance
// -> consistent unit of work across the request

Singleton: Én i hele programmets levetid

Singleton-tjenester opprettes én gang og gjenbrukes i hele applikasjonens levetid. Bruk dem for tjenester som er kostbare å opprette og trådsikre, for eksempel konfigurasjonsbuffere.

builder.Services.AddSingleton<IMemoryCache, MemoryCache>();

// Or register a pre-built instance:
var config = new AppConfig { MaxRetries = 3 };
builder.Services.AddSingleton<IAppConfig>(config);

Sammenligne alle tre

En rask sammenligning side om side:

Transient – ny instans ved hver forespørsel; tilstandsløse hjelpefunksjoner
Scoped – én per HTTP-forespørsel; DbContext, Unit of Work
Singleton – én i hele applikasjonens levetid; buffere, konfigurasjon

Problemet med captive dependencies

Det er en vanlig feil å injisere en Scoped- eller Transient-tjeneste i en Singleton. Singleton-tjenesten holder da en referanse til den kortlivede tjenesten og holder den i live for lenge.

// BAD: Singleton captures a Scoped service
public class MySingleton
{
    private readonly AppDbContext _db; // Scoped!
    public MySingleton(AppDbContext db) => _db = db;
    // _db is now stuck alive for the app's lifetime
}

Oppdage brudd på scope-regler

Aktiver ValidateScopes slik at containeren kaster et unntak ved oppstart hvis den oppdager en captive dependency. Dette fanger opp feil før de forårsaker dataproblemer i produksjon.

builder.Host.UseDefaultServiceProvider(options =>
{
    options.ValidateScopes = true;   // detect captive deps
    options.ValidateOnBuild = true;  // fail fast at start
});

Scoped-tjenester utenfor en forespørsel

For å hente Scoped-tjenester i en bakgrunnsoppgave oppretter man et eksplisitt scope ved hjelp av IServiceScopeFactory. Hent aldri Scoped-tjenester direkte fra rotcontaineren.

public class MyWorker : BackgroundService
{
    private readonly IServiceScopeFactory _factory;

    public MyWorker(IServiceScopeFactory factory) => _factory = factory;

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        using var scope = _factory.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
        await db.Users.ToListAsync(ct);
    }
}

Transient-tjenester som kan frigjøre ressurser

Transient-tjenester som implementerer IDisposable og hentes fra rotcontaineren, spores helt til containeren avhendes (ved avslutning av appen). Hent dem innenfor et scope, slik at ressursene frigjøres raskt.

// Correctly scoped transient disposable
using var scope = sp.CreateScope();
var svc = scope.ServiceProvider.GetRequiredService<MyDisposableService>();
await svc.DoWorkAsync();
// svc.Dispose() called when scope is disposed

Velge riktig levetid

En enkel veiledning for valg:

Er tjenesten tilstandsløs? → Transient
Er den avhengig av en forespørsel (for eksempel brukeridentitet eller DbContext)? → Scoped
Er den trådsikker og kostbar å opprette? → Singleton

I praksis: Tre levetider sammen

En typisk web-API registrerer ulike tjenester med passende levetider for å sikre korrekt funksjon og god ytelse.

builder.Services.AddSingleton<IConfiguration>(builder.Configuration);
builder.Services.AddSingleton<ICacheService, RedisCacheService>();

builder.Services.AddScoped<AppDbContext>();
builder.Services.AddScoped<IOrderRepository, OrderRepository>();
builder.Services.AddScoped<OrderService>();

builder.Services.AddTransient<IEmailSender, SendGridEmailSender>();

Kunnskapssjekk

Hvilket problem oppstår når en Singleton-tjeneste holder en referanse til en Scoped-tjeneste?

Besvar den i den interaktive leksjonen

Oppsummering: Tjenestele vetider

Viktigste punkter:

Transient: ny instans hver gang – egnet for tilstandsløse, lette tjenester
Scoped: én instans per forespørsel – DbContext, repositories, unit of work
Singleton: én instans i hele programmets levetid – buffere, konfigurasjon, trådsikre hjelpefunksjoner
Injiser aldri kortlivede tjenester i tjenester med lengre levetid (captive dependency)
Bruk IServiceScopeFactory for å hente Scoped-tjenester i bakgrunnsoppgaver

Gratis å komme i gang

Lær deg C# med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 93
Leksjoner: 346

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Tjenestelevetider: Transient, Scoped, Singleton» gratis?

Ja – hele teksten i «Tjenestelevetider: Transient, Scoped, Singleton» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av C# Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i C# Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Tjenestelevetider: Transient, Scoped, Singleton»?

Lær hvordan levetidene Transient, Scoped og Singleton påvirker opprettelse, deling og frigjøring av objekter. Du øver på C# Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med C# Academy?

Ingen tidligere erfaring er nødvendig. C# Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Tjenestelevetider: Transient, Scoped, Singleton»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne C# Academy-leksjonen?

Ja. Alle C# Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Grunnleggende om DI-containere
Tjenestelevetider: Transient, Scoped, Singleton
Konstruktørinjeksjon og grensesnitt
Factory- og Options-mønstre

← Tilbake til C# Academy