Generic Host

// Worker Service using Generic Host
var builder = Host.CreateApplicationBuilder(args);
builder.Services.AddHostedService<Worker>();
var host = builder.Build();
host.Run();

// ASP.NET Core app using the same underlying Generic Host infrastructure
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.Run();

Common follow-ups: How does WebApplicationBuilder extend the base Generic Host with web-specific features?;What existed before the Generic Host was introduced in .NET Core 2.1?

// Modern (.NET 7+)
var builder = Host.CreateApplicationBuilder(args);
builder.Services.AddHostedService<Worker>();
var host = builder.Build();

// Older style, still supported
var host = Host.CreateDefaultBuilder(args)
    .ConfigureServices((context, services) => {
        services.AddHostedService<Worker>();
    })
    .Build();

Common follow-ups: Are there any capabilities CreateDefaultBuilder has that CreateApplicationBuilder lacks?;How does this migration affect existing ConfigureServices callback code?

public class MyService(IHostApplicationLifetime lifetime) : IHostedService {
    public Task StartAsync(CancellationToken ct) {
        lifetime.ApplicationStarted.Register(() => Console.WriteLine("Started"));
        lifetime.ApplicationStopping.Register(() => Console.WriteLine("Stopping..."));
        return Task.CompletedTask;
    }
    public Task StopAsync(CancellationToken ct) => Task.CompletedTask;
}

Common follow-ups: What is IHostApplicationLifetime and what events does it expose?;How do you configure the ShutdownTimeout duration?

var builder = Host.CreateApplicationBuilder(args);

// All three configured through the same builder instance
builder.Configuration.AddJsonFile("custom-settings.json");
builder.Services.AddHostedService<Worker>();
builder.Logging.AddConsole().SetMinimumLevel(LogLevel.Debug);

var host = builder.Build();
host.Run();

Common follow-ups: How does this unified builder pattern compare to the older Startup.cs ConfigureServices/Configure split?;What happens if you try to modify builder.Services after calling Build()?

var builder = Host.CreateApplicationBuilder(args);
builder.Services.AddSingleton<ICommandProcessor, CommandProcessor>();
builder.Services.AddHostedService<BackgroundSyncService>();
var host = builder.Build();

// Resolve and use a service directly for one-off interactive logic
var processor = host.Services.GetRequiredService<ICommandProcessor>();
await processor.ProcessAsync(args);

// Then run the host for its long-running hosted services
await host.RunAsync();

Common follow-ups: What's the risk of resolving services directly from host.Services outside the normal DI injection flow?;How does this differ from a purely interactive console app with no hosted services at all?

var builder = Host.CreateApplicationBuilder(args);

if (builder.Environment.IsDevelopment()) {
    builder.Services.AddSingleton<IEmailSender, FakeEmailSender>();  // no real emails sent locally
} else {
    builder.Services.AddSingleton<IEmailSender, SmtpEmailSender>();
}

Common follow-ups: How is the environment name actually determined at startup?;How do you add support for a custom environment name beyond the standard three?

var builder = Host.CreateApplicationBuilder(args);
// In Development, these validations run automatically at Build() time:
// - ValidateOnBuild: catches missing service registrations immediately
// - ValidateScopes: catches captive dependency (Singleton -> Scoped) issues

var host = builder.Build();  // throws here if misconfigured, not later at runtime

Common follow-ups: Why are these validations typically disabled in Production for performance reasons?;How do you explicitly enable them in Production if you want the extra safety despite the cost?

var builder = Host.CreateApplicationBuilder(args);
builder.Services.AddWindowsService(options => options.ServiceName = "MyWorkerService");
builder.Services.AddSystemd();
builder.Services.AddHostedService<Worker>();

var host = builder.Build();
host.Run();  // automatically detects and adapts to the actual hosting context

Common follow-ups: What logging differences occur when running under systemd versus interactively?;How do you install and manage a .NET Worker Service as an actual Windows Service?

public class DatabaseReadinessService : IHostedService {
    public async Task StartAsync(CancellationToken ct) {
        await _db.Database.CanConnectAsync(ct);  // blocks until DB is verified reachable
        _readinessState.MarkReady();
    }
    public Task StopAsync(CancellationToken ct) => Task.CompletedTask;
}
// Registered BEFORE other hosted services to enforce ordering

Common follow-ups: How does this interact with a Kubernetes readiness probe for traffic gating?;What happens if this critical startup task itself times out or fails?

// Default: ConsoleLifetime, handles Ctrl+C and SIGTERM directly
var host = Host.CreateApplicationBuilder(args).Build();

// Explicit: WindowsServiceLifetime, integrates with Windows SCM
builder.Services.AddWindowsService();  // swaps in WindowsServiceLifetime when actually running as a service

Common follow-ups: How would you write a custom IHostLifetime for an unsupported hosting scenario?;What happens if UseWindowsService() is called but the app isn't actually running as a Windows Service?