Asp.Net Core Service Lifetimes Transient Scoped Singleton Complete Guide

1. Setting Up an ASP.NET Core Project

First, let's set up a basic ASP.NET Core Web API project. You can do this using the .NET CLI or Visual Studio.

Using .NET CLI:

dotnet new webapi -n ServiceLifetimeExamples
cd ServiceLifetimeExamples

Or Using Visual Studio:

• Open Visual Studio.
• Create a new ASP.NET Core Web API project named ServiceLifetimeExamples.
• Make sure you target .NET 6.0 or later.

2. Creating Interfaces and Services

We'll create three services, each corresponding to one of the lifetimes: Transient, Scoped, and Singleton.

Services/ITransientService.cs

public interface ITransientService
{
    Guid InstanceId { get; }
}

Services/TransientService.cs

using System;

public class TransientService : ITransientService
{
    public Guid InstanceId { get; } = Guid.NewGuid();
}

Services/IScopedService.cs

public interface IScopedService
{
    Guid InstanceId { get; }
}

Services/ScopedService.cs

using System;

public class ScopedService : IScopedService
{
    public Guid InstanceId { get; } = Guid.NewGuid();
}

Services/ISingletonService.cs

public interface ISingletonService
{
    Guid InstanceId { get; }
}

Services/SingletonService.cs

using System;

public class SingletonService : ISingletonService
{
    public Guid InstanceId { get; } = Guid.NewGuid();
}

3. Registering Services with Different Lifetimes

In the Startup.cs file (or Program.cs if you're using minimal hosting model), register the services with their respective lifetimes:

Minimal Hosting Model (Program.cs)

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();

builder.Services.AddTransient<ITransientService, TransientService>();
builder.Services.AddScoped<IScopedService, ScopedService>();
builder.Services.AddSingleton<ISingletonService, SingletonService>();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}

app.UseHttpsRedirection();

app.UseAuthorization();

app.MapControllers();

app.Run();

Traditional Hosting Model (Startup.cs)

If you're using the traditional hosting model, add the registrations in the ConfigureServices method:

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();

    services.AddTransient<ITransientService, TransientService>();
    services.AddScoped<IScopedService, ScopedService>();
    services.AddSingleton<ISingletonService, SingletonService>();
}

4. Injecting and Using Services in the Controller

Create an ExampleController to demonstrate how each service behaves with its given lifetime.

Controllers/ExampleController.cs

using Microsoft.AspNetCore.Mvc;
using ServiceLifetimeExamples.Services;

namespace ServiceLifetimeExamples.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class ExampleController : ControllerBase
    {
        private readonly ITransientService _transientService;
        private readonly IScopedService _scopedService;
        private readonly ISingletonService _singletonService;

        public ExampleController(ITransientService transientService,
                                IScopedService scopedService,
                                ISingletonService singletonService)
        {
            _transientService = transientService;
            _scopedService = scopedService;
            _singletonService = singletonService;
        }

        [HttpGet("transient")]
        public IActionResult GetTransient()
        {
            return Ok(new 
            {
                InstanceId = _transientService.InstanceId
            });
        }

        [HttpGet("scoped")]
        public IActionResult GetScoped()
        {
            return Ok(new 
            {
                InstanceId = _scopedService.InstanceId
            });
        }

        [HttpGet("singleton")]
        public IActionResult GetSingleton()
        {
            return Ok(new 
            {
                InstanceId = _singletonService.InstanceId
            });
        }
    }
}

5. Testing the Service Lifetimes

Run the application and use a tool like Postman or simply your browser to make requests to each endpoint:

Running the Application

Using .NET CLI:

dotnet run

Or Use the Run Button in Visual Studio

• Navigate to https://localhost:<port>/example/transient
• Navigate to https://localhost:<port>/example/scoped
• Navigate to https://localhost:<port>/example/singleton

Making Requests

Transient Services

Make multiple requests to the /example/transient endpoint:

• You should see a different InstanceId for each request.

Example Response:

{
  "instanceId": "3fa85f64-5717-4562-b3fc-2c963f66a333"
}

Scoped Services

Within the same request scope (i.e., the same HTTP request):

• The InstanceId remains the same.

Make multiple requests to the /example/scoped endpoint:

• You should see a different InstanceId for each request scope.

Example Response:

{
  "instanceId": "3fa85f64-5717-4562-b3fc-2c963f66a333"
}

Singleton Services

The InstanceId remains the same across all requests:

• Regardless of how many times you make requests, you'll receive the same InstanceId.

Example Response:

{
  "instanceId": "3fa85f64-5717-4562-b3fc-2c963f66a333"
}

Further Demonstration: Different Request Scopes

Testing Different Scopes for Scoped Services

To see the difference in scope behavior, you can create another controller that uses the same scoped service and make requests to both controllers within a single HTTP request scope.

Controllers/AnotherExampleController.cs

using Microsoft.AspNetCore.Mvc;
using ServiceLifetimeExamples.Services;

namespace ServiceLifetimeExamples.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class AnotherExampleController : ControllerBase
    {
        private readonly ITransientService _transientService;
        private readonly IScopedService _scopedService;
        private readonly ISingletonService _singletonService;

        public AnotherExampleController(ITransientService transientService,
                                        IScopedService scopedService,
                                        ISingletonService singletonService)
        {
            _transientService = transientService;
            _scopedService = scopedService;
            _singletonService = singletonService;
        }

        [HttpGet("scoped")]
        public IActionResult GetScoped()
        {
            return Ok(new 
            {
                InstanceId = _scopedService.InstanceId
            });
        }
    }
}

Making Requests

1. Navigate to https://localhost:<port>/example/scoped

   • Record the InstanceId returned.

2. Navigate to https://localhost:<port>/anotherexample/scoped

   • If both requests are made within the same browser session or HTTP client (which maintains a single request scope), you should see the same InstanceId for both endpoints.

Example Response (both requests):

{
  "instanceId": "3fa85f64-5717-4562-b3fc-2c963f66a333"
}

Summary of Service Lifetimes

• Transient: A new instance is created each time the service is resolved.
• Scoped: A single instance is created per request scope. If the request scope ends, the instance is disposed of.
• Singleton: A single instance is created and shared throughout the application's lifetime.

Conclusion

These examples should give you a clear understanding of how service lifetimes work in ASP.NET Core. Properly managing service lifetimes is essential for building efficient and effective applications. Feel free to experiment and test these examples in different scenarios to deepen your understanding.

Additional Resources

• Microsoft Official Documentation on Service Lifetimes
• .NET Dependency Injection Overview
• Understanding DI in ASP.NET Core by Scott Hanselman