Generic Host and dependency injection

A class that makes its own dependencies with new decides in code which clock, store and sender it uses, so a test cannot replace them and every change to them reaches into the class. The .NET Generic HostGeneric Host: The host of Microsoft.Extensions.Hosting: one object that owns an app's services, configuration, logging and lifetime, and starts and stops its hosted services. Host.CreateApplicationBuilder sets one up. turns that around: in this lesson’s first program, one call gives a console app configuration, console logging, an orderly start and stop, and a service container that builds every object by dependency injectiondependency injection: Giving an object the objects it depends on, usually as constructor parameters, instead of letting it create them. In .NET a service container reads the registrations and builds each object with its dependencies..

You will compose an app on the Generic Host, give each service the lifetime it needs, catch a lifetime mistake before the app handles its first message, and choose between implementations by key.

The host builds every object your app needs

The Generic Host, from the Microsoft.Extensions.Hosting package, is one object that owns an app’s services, its configuration, its logging and its lifetime. Dependency injection is how it builds the services: a class lists what it needs as constructor parameters, here with a primary constructor, and the container passes them in. The program greeting.cs registers two services, a greeter and a hosted servicehosted service: A class that implements IHostedService, often by deriving from BackgroundService, registered with AddHostedService. The host starts it after the app is built and stops it when the app shuts down. that the host starts and stops:

#:package Microsoft.Extensions.Hosting@10.0.12
#:property PublishAot=false
// A console app on the Generic Host: one call sets up configuration, logging and a service container; the greeting
// service gets what it needs through its constructor. Everything is written through the logger, so lines keep their order.
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);
builder.Services.AddSingleton<IGreeter, Greeter>();
builder.Services.AddHostedService<GreetingService>();

using (IHost host = builder.Build())
{
    await host.StartAsync();   // starts every hosted service, then reports that the app has started
    await host.StopAsync();    // what Run does after Ctrl+C or SIGTERM: stops the services in reverse order
}                              // disposing the host disposes its services and flushes the console logger
Console.WriteLine("host stopped and disposed");

interface IGreeter { string Greet(string city); }

sealed class Greeter : IGreeter
{
    public string Greet(string city) => $"Namaste, {city}!";
}

sealed class GreetingService(IGreeter greeter, IHostEnvironment environment, ILogger<GreetingService> logger) : IHostedService
{
    public Task StartAsync(CancellationToken cancellationToken)
    {
        logger.LogInformation("{Greeting} (environment {Environment})", greeter.Greet("Pune"), environment.EnvironmentName);
        return Task.CompletedTask;
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        logger.LogInformation("Greeting service stopped");
        return Task.CompletedTask;
    }
}

from session import run

# network: true. greeting.cs names Microsoft.Extensions.Hosting 10.0.12 in its #:package line, and dotnet run
# restores it, with the packages it depends on, from nuget.org into the session's own, empty home folder. The second
# run sets DOTNET_ENVIRONMENT, the variable the host reads for the environment's name.
run("""
cd greeting
dotnet run greeting.cs
DOTNET_ENVIRONMENT=Development dotnet run greeting.cs
""", network=True)

$ cd greeting
$ dotnet run greeting.cs
info: GreetingService[0]
      Namaste, Pune! (environment Production)
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Production
info: Microsoft.Hosting.Lifetime[0]
      Content root path: greeting
info: Microsoft.Hosting.Lifetime[0]
      Application is shutting down...
info: GreetingService[0]
      Greeting service stopped
host stopped and disposed
$ DOTNET_ENVIRONMENT=Development dotnet run greeting.cs
info: GreetingService[0]
      Namaste, Pune! (environment Development)
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
      Content root path: greeting
info: Microsoft.Hosting.Lifetime[0]
      Application is shutting down...
info: GreetingService[0]
      Greeting service stopped
host stopped and disposed

The class GreetingService never created an IGreeter, an environment or a logger: it asked for them and got them. Because every dependency arrives through the constructor, a unit test can create the service with a fake greeter and no host at all, and a change of greeter never touches the class. The container also calls Dispose on the disposable objects it created, when the host is disposed, so a service never disposes what it was given. The host reported Production because nothing set DOTNET_ENVIRONMENT, and the same program reported Development when the variable said so. Run does what this program did by hand: it calls StartAsync, waits for Ctrl+C or SIGTERM, calls StopAsync and disposes the host, as the using block did here. Step through the run:

Every registration also says how long its object lives. A singleton is created once and shared by the whole app. A scoped service is created once per scope, such as one message, and disposed when the scope ends; code opens a scope with IServiceScopeFactory.CreateScope(). A transient service is created every time something asks for it. A captive dependency is a long-lived service that holds a shorter-lived one, and the host’s ValidateScopes and ValidateOnBuild checks report it when the host is built. Keyed services register several implementations of one interface under keys such as sms and email, and a constructor asks for one with [FromKeyedServices]. A parameter of type IEnumerable<T> receives every registration of T. An open generic registration serves every closed type of a generic interface, and a factory registration builds an object in code when a constructor is not enough.

Three lifetimes decide when objects are made and disposed Pro: opens with a Pro, Premium or Ultimate pass