Tasks That Run Forever

Need to process queue every minute? Send emails in background? Background Services run continuously alongside your ASP.NET app. Perfect for scheduled tasks, workers.

Create Background Service

public class EmailProcessorService : BackgroundService
{
    private readonly ILogger _logger;
    private readonly IServiceProvider _serviceProvider;

    public EmailProcessorService(
        ILogger logger,
        IServiceProvider serviceProvider)
    {
        _logger = logger;
        _serviceProvider = serviceProvider;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Email Processor Service started");

        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                // Create scope for scoped services
                using var scope = _serviceProvider.CreateScope();
                var emailService = scope.ServiceProvider.GetRequiredService();

                // Process pending emails
                await emailService.ProcessPendingEmailsAsync();

                _logger.LogInformation("Processed emails at {Time}", DateTime.UtcNow);

                // Wait 1 minute before next run
                await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error processing emails");
                await Task.Delay(TimeSpan.FromSeconds(30), stoppingToken);
            }
        }

        _logger.LogInformation("Email Processor Service stopped");
    }
}

// Register in Program.cs
builder.Services.AddHostedService();

public class CleanupService : BackgroundService
{
    private readonly ILogger _logger;
    private readonly IServiceProvider _serviceProvider;
    private Timer? _timer;

    public CleanupService(
        ILogger logger,
        IServiceProvider serviceProvider)
    {
        _logger = logger;
        _serviceProvider = serviceProvider;
    }

    protected override Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Cleanup Service started");

        // Run every hour
        _timer = new Timer(
            DoWork,
            null,
            TimeSpan.Zero,  // Start immediately
            TimeSpan.FromHours(1));  // Run every hour

        return Task.CompletedTask;
    }

    private async void DoWork(object? state)
    {
        _logger.LogInformation("Cleanup running at {Time}", DateTime.UtcNow);

        try
        {
            using var scope = _serviceProvider.CreateScope();
            var dbContext = scope.ServiceProvider.GetRequiredService();

            // Delete old records
            var cutoffDate = DateTime.UtcNow.AddDays(-30);
            var oldRecords = await dbContext.Logs
                .Where(l => l.CreatedAt < cutoffDate)
                .ToListAsync();

            dbContext.Logs.RemoveRange(oldRecords);
            await dbContext.SaveChangesAsync();

            _logger.LogInformation("Deleted {Count} old records", oldRecords.Count);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error during cleanup");
        }
    }

    public override Task StopAsync(CancellationToken cancellationToken)
    {
        _timer?.Change(Timeout.Infinite, 0);
        _logger.LogInformation("Cleanup Service stopped");
        return base.StopAsync(cancellationToken);
    }

    public override void Dispose()
    {
        _timer?.Dispose();
        base.Dispose();
    }
}

Queue Processing Service

public class OrderProcessingService : BackgroundService
{
    private readonly ILogger _logger;
    private readonly IServiceProvider _serviceProvider;

    public OrderProcessingService(
        ILogger logger,
        IServiceProvider serviceProvider)
    {
        _logger = logger;
        _serviceProvider = serviceProvider;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                using var scope = _serviceProvider.CreateScope();
                var orderQueue = scope.ServiceProvider.GetRequiredService();
                var orderService = scope.ServiceProvider.GetRequiredService();

                // Dequeue and process orders
                var order = await orderQueue.DequeueAsync(stoppingToken);

                if (order != null)
                {
                    _logger.LogInformation("Processing order {OrderId}", order.Id);

                    await orderService.ProcessAsync(order);
                    await orderQueue.CompleteAsync(order.Id);

                    _logger.LogInformation("Order {OrderId} processed", order.Id);
                }
                else
                {
                    // No orders in queue, wait a bit
                    await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);
                }
            }
            catch (OperationCanceledException)
            {
                // Expected when stopping
                break;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error processing order");
                await Task.Delay(TimeSpan.FromSeconds(10), stoppingToken);
            }
        }
    }
}

public class MonitoringService : BackgroundService
{
    private readonly ILogger _logger;
    private DateTime _lastRunTime = DateTime.MinValue;
    public bool IsHealthy { get; private set; } = true;

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                // Do monitoring work
                await MonitorSystemAsync();

                _lastRunTime = DateTime.UtcNow;
                IsHealthy = true;

                await Task.Delay(TimeSpan.FromMinutes(5), stoppingToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Monitoring failed");
                IsHealthy = false;
            }
        }
    }

    private async Task MonitorSystemAsync()
    {
        // Check system health
        _logger.LogInformation("System healthy at {Time}", DateTime.UtcNow);
    }
}

// Health check
public class BackgroundServiceHealthCheck : IHealthCheck
{
    private readonly MonitoringService _monitoringService;

    public BackgroundServiceHealthCheck(MonitoringService monitoringService)
    {
        _monitoringService = monitoringService;
    }

    public Task CheckHealthAsync(
        HealthCheckContext context,
        CancellationToken cancellationToken = default)
    {
        if (_monitoringService.IsHealthy)
        {
            return Task.FromResult(HealthCheckResult.Healthy("Monitoring service running"));
        }

        return Task.FromResult(HealthCheckResult.Unhealthy("Monitoring service failed"));
    }
}

// Register
builder.Services.AddSingleton();
builder.Services.AddHostedService(sp => sp.GetRequiredService());
builder.Services.AddHealthChecks()
    .AddCheck("monitoring-service");

"Needed to process 100k+ emails daily. Created BackgroundService with queue. Runs 24/7, processes emails in batches. Zero downtime. Easier than setting up separate worker service."

APIs in 10 Lines of Code

MVC Controllers for simple API? Overkill. Minimal APIs (.NET 6+) create HTTP endpoints with minimal ceremony. Perfect for microservices, simple APIs.

Traditional Controller vs Minimal API

//  Traditional Controller (verbose)
[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    private readonly IUserService _userService;
    
    public UsersController(IUserService userService)
    {
        _userService = userService;
    }
    
    [HttpGet]
    public async Task>> GetUsers()
    {
        var users = await _userService.GetAllAsync();
        return Ok(users);
    }
    
    [HttpGet("{id}")]
    public async Task> GetUser(int id)
    {
        var user = await _userService.GetByIdAsync(id);
        if (user == null) return NotFound();
        return Ok(user);
    }
    
    [HttpPost]
    public async Task> CreateUser(User user)
    {
        var created = await _userService.CreateAsync(user);
        return CreatedAtAction(nameof(GetUser), new { id = created.Id }, created);
    }
}

// Many files, boilerplate code, ceremony

//  Minimal API (concise!)
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddScoped();

var app = builder.Build();

app.MapGet("/api/users", async (IUserService service) => 
    await service.GetAllAsync());

app.MapGet("/api/users/{id}", async (int id, IUserService service) =>
{
    var user = await service.GetByIdAsync(id);
    return user is not null ? Results.Ok(user) : Results.NotFound();
});

app.MapPost("/api/users", async (User user, IUserService service) =>
{
    var created = await service.CreateAsync(user);
    return Results.Created($"/api/users/{created.Id}", created);
});

app.Run();

// Everything in Program.cs, minimal code!

var builder = WebApplication.CreateBuilder(args);

// Add services
builder.Services.AddDbContext();
builder.Services.AddScoped();

var app = builder.Build();

// GET all users
app.MapGet("/api/users", async (IUserRepository repo) =>
{
    var users = await repo.GetAllAsync();
    return Results.Ok(users);
})
.WithName("GetUsers")
.Produces>(200);

// GET user by ID
app.MapGet("/api/users/{id:int}", async (int id, IUserRepository repo) =>
{
    var user = await repo.GetByIdAsync(id);
    return user is not null 
        ? Results.Ok(user) 
        : Results.NotFound(new { message = "User not found" });
})
.WithName("GetUser")
.Produces(200)
.Produces(404);

// POST create user
app.MapPost("/api/users", async (User user, IUserRepository repo) =>
{
    if (string.IsNullOrWhiteSpace(user.Name))
        return Results.BadRequest(new { message = "Name is required" });
    
    var created = await repo.CreateAsync(user);
    return Results.CreatedAtRoute("GetUser", new { id = created.Id }, created);
})
.Accepts("application/json")
.Produces(201)
.Produces(400);

// PUT update user
app.MapPut("/api/users/{id:int}", async (int id, User user, IUserRepository repo) =>
{
    var existing = await repo.GetByIdAsync(id);
    if (existing is null)
        return Results.NotFound();
    
    user.Id = id;
    await repo.UpdateAsync(user);
    return Results.NoContent();
})
.Produces(204)
.Produces(404);

// DELETE user
app.MapDelete("/api/users/{id:int}", async (int id, IUserRepository repo) =>
{
    var deleted = await repo.DeleteAsync(id);
    return deleted 
        ? Results.NoContent() 
        : Results.NotFound();
})
.Produces(204)
.Produces(404);

app.Run();

Dependency Injection

// Services automatically injected from DI
app.MapGet("/api/products", async (
    IProductService productService,  // Injected
    ILogger logger,          // Injected
    HttpContext context) =>           // Also available
{
    logger.LogInformation("Getting products for user {User}", context.User.Identity?.Name);
    return await productService.GetAllAsync();
});

// Multiple services
app.MapPost("/api/orders", async (
    Order order,
    IOrderService orderService,
    IInventoryService inventoryService,
    IEmailService emailService) =>
{
    var created = await orderService.CreateAsync(order);
    await inventoryService.UpdateStockAsync(order.Items);
    await emailService.SendOrderConfirmationAsync(created);
    return Results.Created($"/api/orders/{created.Id}", created);
});

// Add auth services
builder.Services.AddAuthentication()
    .AddJwtBearer();
builder.Services.AddAuthorization();

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

// Require authentication
app.MapGet("/api/profile", async (HttpContext context) =>
{
    return Results.Ok(new { user = context.User.Identity?.Name });
})
.RequireAuthorization();  // Requires authenticated user

// Require specific role
app.MapDelete("/api/users/{id}", async (int id, IUserRepository repo) =>
{
    await repo.DeleteAsync(id);
    return Results.NoContent();
})
.RequireAuthorization("AdminOnly");

// Require policy
app.MapPost("/api/admin/config", async (Config config) =>
{
    // Admin action
})
.RequireAuthorization(policy => policy.RequireRole("Admin"));

Validation & Error Handling

// Install: FluentValidation.AspNetCore
builder.Services.AddValidatorsFromAssemblyContaining();

// Validator
public class CreateUserValidator : AbstractValidator
{
    public CreateUserValidator()
    {
        RuleFor(x => x.Email).NotEmpty().EmailAddress();
        RuleFor(x => x.Name).NotEmpty().MaximumLength(100);
        RuleFor(x => x.Age).GreaterThan(0).LessThan(150);
    }
}

// Endpoint with validation
app.MapPost("/api/users", async (
    CreateUserDto dto,
    IValidator validator,
    IUserService service) =>
{
    var validationResult = await validator.ValidateAsync(dto);
    if (!validationResult.IsValid)
    {
        return Results.ValidationProblem(validationResult.ToDictionary());
    }
    
    var user = await service.CreateAsync(dto);
    return Results.Created($"/api/users/{user.Id}", user);
});

// Global exception handler
app.UseExceptionHandler(exceptionHandlerApp =>
{
    exceptionHandlerApp.Run(async context =>
    {
        context.Response.StatusCode = 500;
        context.Response.ContentType = "application/json";
        
        var error = context.Features.Get();
        if (error != null)
        {
            await context.Response.WriteAsJsonAsync(new
            {
                error = "An error occurred",
                detail = error.Error.Message
            });
        }
    });
});

“Rewrote microservice API from MVC to Minimal APIs. Code reduced from 500 lines across 5 files to 150 lines in Program.cs. Startup time halved. Easier for juniors to understand.”

Know When Your App Is Sick

Load balancer needs to know: is app healthy? Database connected? Redis available? Health checks provide instant status.

Basic Health Check Setup

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

// Add health checks
builder.Services.AddHealthChecks();

var app = builder.Build();

// Map health check endpoint
app.MapHealthChecks("/health");

app.Run();

// GET /health
// Response: Healthy (200 OK)

Database Health Check

// Install package
// dotnet add package AspNetCore.HealthChecks.SqlServer

// Program.cs
builder.Services.AddHealthChecks()
    .AddSqlServer(
        connectionString: builder.Configuration.GetConnectionString("DefaultConnection"),
        name: "sql-server",
        failureStatus: HealthStatus.Degraded,
        tags: new[] { "db", "sql" }
    );

// GET /health
// If DB down: Unhealthy (503)
// If DB slow: Degraded (200)
// If DB OK: Healthy (200)

// Install packages
// dotnet add package AspNetCore.HealthChecks.Redis
// dotnet add package AspNetCore.HealthChecks.Npgsql
// dotnet add package AspNetCore.HealthChecks.Rabbitmq

builder.Services.AddHealthChecks()
    .AddSqlServer(
        connectionString: config["ConnectionStrings:DefaultConnection"],
        name: "database")
    .AddRedis(
        redisConnectionString: config["Redis:ConnectionString"],
        name: "redis-cache")
    .AddRabbitMQ(
        rabbitConnectionString: config["RabbitMQ:ConnectionString"],
        name: "message-queue")
    .AddUrlGroup(
        uri: new Uri("https://api.external-service.com/health"),
        name: "external-api");

// Separate endpoints for different checks
app.MapHealthChecks("/health/live", new HealthCheckOptions
{
    Predicate = _ => false // Just check if app is running
});

app.MapHealthChecks("/health/ready", new HealthCheckOptions
{
    Predicate = check => check.Tags.Contains("ready")
});

Custom Health Check

public class DiskSpaceHealthCheck : IHealthCheck
{
    public Task CheckHealthAsync(
        HealthCheckContext context,
        CancellationToken cancellationToken = default)
    {
        var drive = DriveInfo.GetDrives().First();
        var freeSpaceGB = drive.AvailableFreeSpace / 1024 / 1024 / 1024;

        if (freeSpaceGB < 1)
        {
            return Task.FromResult(
                HealthCheckResult.Unhealthy(
                    $"Low disk space: {freeSpaceGB}GB remaining"));
        }

        if (freeSpaceGB < 5)
        {
            return Task.FromResult(
                HealthCheckResult.Degraded(
                    $"Disk space getting low: {freeSpaceGB}GB remaining"));
        }

        return Task.FromResult(
            HealthCheckResult.Healthy(
                $"Disk space OK: {freeSpaceGB}GB remaining"));
    }
}

// Register
builder.Services.AddHealthChecks()
    .AddCheck("disk-space");

Detailed JSON Response

app.MapHealthChecks("/health", new HealthCheckOptions
{
    ResponseWriter = async (context, report) =>
    {
        context.Response.ContentType = "application/json";
        
        var result = JsonSerializer.Serialize(new
        {
            status = report.Status.ToString(),
            checks = report.Entries.Select(e => new
            {
                name = e.Key,
                status = e.Value.Status.ToString(),
                description = e.Value.Description,
                duration = e.Value.Duration.TotalMilliseconds
            }),
            totalDuration = report.TotalDuration.TotalMilliseconds
        });

        await context.Response.WriteAsync(result);
    }
});

// GET /health
// {
//   "status": "Healthy",
//   "checks": [
//     {
//       "name": "database",
//       "status": "Healthy",
//       "description": "SQL Server is responsive",
//       "duration": 25.3
//     },
//     {
//       "name": "redis-cache",
//       "status": "Healthy",
//       "description": null,
//       "duration": 8.1
//     }
//   ],
//   "totalDuration": 45.7
// }

# Kubernetes deployment.yaml
apiVersion: apps/v1
kind: Deployment
spec:
  template:
    spec:
      containers:
      - name: myapp
        image: myapp:latest
        livenessProbe:
          httpGet:
            path: /health/live
            port: 80
          initialDelaySeconds: 10
          periodSeconds: 30
        readinessProbe:
          httpGet:
            path: /health/ready
            port: 80
          initialDelaySeconds: 5
          periodSeconds: 10

“Added health checks to all microservices. Kubernetes auto-restarts unhealthy pods. Database connection issues detected instantly. Load balancer removes sick instances. Zero manual intervention. Self-healing infrastructure.”

Long-Running Tasks in ASP.NET Core

Need scheduled jobs? Background processing? Email queue? IHostedService runs tasks in background without blocking requests.

Basic Background Service

public class EmailQueueService : BackgroundService
{
    private readonly ILogger _logger;
    private readonly IServiceProvider _services;

    public EmailQueueService(
        ILogger logger,
        IServiceProvider services)
    {
        _logger = logger;
        _services = services;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Email Queue Service started");

        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                // Create scope for scoped services
                using var scope = _services.CreateScope();
                var emailService = scope.ServiceProvider
                    .GetRequiredService();

                // Process emails
                await emailService.ProcessQueueAsync();

                // Wait 30 seconds before next run
                await Task.Delay(TimeSpan.FromSeconds(30), stoppingToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error processing email queue");
            }
        }

        _logger.LogInformation("Email Queue Service stopped");
    }
}

// Program.cs - Register service
builder.Services.AddHostedService();

public class DailyReportService : BackgroundService
{
    private readonly ILogger _logger;
    private readonly IServiceProvider _services;

    public DailyReportService(
        ILogger logger,
        IServiceProvider services)
    {
        _logger = logger;
        _services = services;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            // Calculate time until next 9 AM
            var now = DateTime.Now;
            var nextRun = DateTime.Today.AddHours(9);
            
            if (now > nextRun)
            {
                nextRun = nextRun.AddDays(1);
            }

            var delay = nextRun - now;
            
            _logger.LogInformation($"Next report at {nextRun}");
            
            // Wait until 9 AM
            await Task.Delay(delay, stoppingToken);

            // Generate report
            using var scope = _services.CreateScope();
            var reportService = scope.ServiceProvider
                .GetRequiredService();
            
            await reportService.GenerateDailyReportAsync();
        }
    }
}

IHostedService vs BackgroundService

// Manual implementation
public class MyService : IHostedService
{
    public Task StartAsync(
        CancellationToken ct)
    {
        // Start logic
        return Task.CompletedTask;
    }

    public Task StopAsync(
        CancellationToken ct)
    {
        // Cleanup
        return Task.CompletedTask;
    }
}

// Easier implementation
public class MyService 
    : BackgroundService
{
    protected override async Task
        ExecuteAsync(
            CancellationToken ct)
    {
        // Long-running work
        while (!ct.IsCancellationRequested)
        {
            await DoWorkAsync();
            await Task.Delay(1000, ct);
        }
    }
}

Real-World Use Cases

“Moved email sending to background service. API responses instant now. Emails send reliably in background. Added retry logic. Zero impact on user experience. Should’ve done this years ago.”

Explicit Error Handling

Exceptions for control flow? Expensive. Hidden. Result pattern makes errors explicit and performant.

Traditional Exception Way

public User GetUser(int id)
{
    var user = _db.Users.Find(id);
    if (user == null)
        throw new NotFoundException("User not found");
    
    if (!user.IsActive)
        throw new InvalidOperationException("User inactive");
    
    return user;
}

// Caller has no idea what exceptions to catch
try
{
    var user = GetUser(123);
}
catch (Exception ex) // Too broad!
{
    // What went wrong?
}

Result Pattern Way

// Result class
public class Result
{
    public bool IsSuccess { get; }
    public T Value { get; }
    public string Error { get; }
    
    private Result(T value)
    {
        IsSuccess = true;
        Value = value;
    }
    
    private Result(string error)
    {
        IsSuccess = false;
        Error = error;
    }
    
    public static Result Success(T value) => new(value);
    public static Result Failure(string error) => new(error);
}

// Usage
public Result GetUser(int id)
{
    var user = _db.Users.Find(id);
    if (user == null)
        return Result.Failure("User not found");
    
    if (!user.IsActive)
        return Result.Failure("User inactive");
    
    return Result.Success(user);
}

// Caller knows exactly what to check
var result = GetUser(123);
if (result.IsSuccess)
{
    var user = result.Value;
    // Success path
}
else
{
    // Handle error
    Console.WriteLine(result.Error);
}

[HttpGet("{id}")]
public IActionResult GetUser(int id)
{
    var result = _userService.GetUser(id);
    
    return result.IsSuccess
        ? Ok(result.Value)
        : NotFound(new { error = result.Error });
}

// Clean, explicit, no exceptions

“Switched from exceptions to Result pattern in hot path. Performance improved 40%. Error handling became explicit. Code reviews caught missing error checks at compile time.”

Build APIs in 5 Lines of Code

Skip controllers, routing, Startup.cs. Minimal APIs (.NET 6+) make simple endpoints incredibly simple.

Traditional Controller Way

// Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
}

public void Configure(IApplicationBuilder app)
{
    app.UseRouting();
    app.UseEndpoints(endpoints => endpoints.MapControllers());
}

// UsersController.cs
[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    [HttpGet]
    public IActionResult Get() => Ok(new[] { "Alice", "Bob" });
}

// 20+ lines for simple endpoint

Minimal API Way

// Program.cs - That's it!
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/api/users", () => new[] { "Alice", "Bob" });

app.Run();

// 5 lines total 

var builder = WebApplication.CreateBuilder(args);

// Add services
builder.Services.AddDbContext();
builder.Services.AddScoped();

var app = builder.Build();

// GET endpoint
app.MapGet("/api/users", async (AppDbContext db) =>
    await db.Users.ToListAsync());

// GET with route parameter
app.MapGet("/api/users/{id}", async (int id, AppDbContext db) =>
    await db.Users.FindAsync(id) is User user
        ? Results.Ok(user)
        : Results.NotFound());

// POST endpoint
app.MapPost("/api/users", async (User user, AppDbContext db) =>
{
    db.Users.Add(user);
    await db.SaveChangesAsync();
    return Results.Created($"/api/users/{user.Id}", user);
});

// PUT endpoint
app.MapPut("/api/users/{id}", async (int id, User updated, AppDbContext db) =>
{
    var user = await db.Users.FindAsync(id);
    if (user is null) return Results.NotFound();
    
    user.Name = updated.Name;
    await db.SaveChangesAsync();
    return Results.Ok(user);
});

// DELETE endpoint
app.MapDelete("/api/users/{id}", async (int id, AppDbContext db) =>
{
    var user = await db.Users.FindAsync(id);
    if (user is null) return Results.NotFound();
    
    db.Users.Remove(user);
    await db.SaveChangesAsync();
    return Results.NoContent();
});

app.Run();

“Migrated webhook receiver from controller to Minimal API. 40 lines became 8. Performance identical. Startup time 30% faster. Perfect for small services.”

// Program.cs
builder.Services.AddHealthChecks()
    .AddDbContextCheck()
    .AddRedis("localhost:6379");

app.MapHealthChecks("/health");

// Visit /health
// Response: Healthy or Unhealthy + details

Custom Check:

public class ApiHealthCheck : IHealthCheck
{
    public async Task CheckHealthAsync(...)
    {
        var isHealthy = await CheckExternalApiAsync();
        return isHealthy 
            ? HealthCheckResult.Healthy()
            : HealthCheckResult.Unhealthy("API down");
    }
}

Use With: Kubernetes liveness probes, monitoring tools.

// Program.cs
builder.Services.AddResponseCaching();

var app = builder.Build();
app.UseResponseCaching();

// Controller
[ResponseCache(Duration = 600)] // 10 minutes
public IActionResult GetProducts()
{
    return Ok(_db.Products.ToList());
}

Headers: Sets Cache-Control headers automatically. Browser + server cache.

Vary: Cache different responses per user: VaryByHeader = "Authorization"

Disable: [ResponseCache(NoStore = true)] for dynamic data.

Lifecycle Hooks

Run code on app start/stop. Warm cache, close connections cleanly.

public class StartupService : IHostedService
{
    public async Task StartAsync(CancellationToken cancellationToken)
    {
        // Runs when app starts
        await WarmCacheAsync();
        await CheckDatabaseConnectionAsync();
    }

    public async Task StopAsync(CancellationToken cancellationToken)
    {
        // Runs when app stops (graceful shutdown)
        await FlushLogsAsync();
        await CloseConnectionsAsync();
    }
}

// Register
services.AddHostedService();

Use Cases: Cache warming, health checks, cleanup tasks, connection pooling.

Execution Order: StartAsync runs before app accepts requests. StopAsync during graceful shutdown.

Built-in Cache

Redis overkill for small apps. IMemoryCache built into .NET. Zero config.

// Startup
services.AddMemoryCache();

// Usage
public class UserService
{
    private readonly IMemoryCache _cache;
    
    public async Task GetUserAsync(int id)
    {
        return await _cache.GetOrCreateAsync(
            $"user-{id}",
            async entry =>
            {
                entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5);
                return await _db.Users.FindAsync(id);
            }
        );
    }
}

When It’s Enough: Single server, moderate traffic, <10GB cache needs.

Upgrade Path: Later swap to Redis. Same IDistributedCache interface.