How to configure service with new net8 Host.CreateApplicationBuilder and bind appsettings.json which allows AOT?

[cirrusone]

It seems like net8 is now recommending use of 'Host.CreateApplicationBuilder' rather than 'Host.CreateDefaultBuilder'. I was able to bind appsettings.json to a class which allowed AOT using the following on the old CreateDefaultBuilder method, how do I do similar using 'Host.CreateApplicationBuilder'?

    public static async Task Main(string[] args)
    {
        IHost host = Host.CreateDefaultBuilder(args)
        .ConfigureServices((hostContext, services) =>
        {
            // https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-8/runtime#configuration-binding-source-generator
            IConfiguration configuration = hostContext.Configuration;
            IConfigurationSection section = configuration.GetSection("DatabaseConfig");

            // !! Configure call - to be replaced with source-gen'd implementation
            services.Configure<DatabaseConfig>(section);

            // !! Get call - to be replaced with source-gen'd implementation
            DatabaseConfig? configOptions0 = section.Get<DatabaseConfig>();

            // !! Bind call - to be replaced with source-gen'd implementation
            DatabaseConfig configOptions1 = new();
            section.Bind(configOptions1);

            services.AddSingleton(configOptions1);
            services.AddHostedService<Worker>();
        })
        .Build();
        await host.RunAsync();
    }

How can I do similar with new Host.CreateApplicationBuilder? I've found a a few posts which suggest using builder.Services.AddOptions<DatabaseConfig>().BindConfiguration("DatabaseConfig"); , but I cannot get this working. The injected object is always empty.

    public static async Task Main(string[] args)
    {
        // New -> Host.CreateApplicationBuilder
        var builder = Host.CreateApplicationBuilder(args);
        builder.Services.AddOptions<DatabaseConfig>().BindConfiguration("DatabaseConfig"); // <- Empty
        builder.Services.AddSingleton<DatabaseConfig>();
        builder.Services.AddHostedService<Worker>();

        var host = builder.Build();
        await host.RunAsync();
    }

Full sample:

WorkerServiceTest.csproj:

<Project Sdk="Microsoft.NET.Sdk.Worker">

  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>disable</ImplicitUsings>
    <InvariantGlobalization>true</InvariantGlobalization>
    <PublishAot>true</PublishAot>
    <PublishTrimmed>true</PublishTrimmed>
    <EnableConfigurationBindingGenerator>true</EnableConfigurationBindingGenerator>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.0" />
    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
  </ItemGroup>
</Project>

appsettings.json:

{
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft.Hosting.Lifetime": "Information"
        }
    },
    "DatabaseConfig": {
        "ConnectionString1": "this",
        "ConnectionString2" : "that"
    }
}

Program:

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System.Threading.Tasks;

namespace WorkerServiceTest;

public static class Program
{
    public static async Task Main(string[] args)
    {
        // New -> Host.CreateApplicationBuilder
        var builder = Host.CreateApplicationBuilder(args);
        builder.Services.AddOptions<DatabaseConfig>().BindConfiguration("DatabaseConfig"); // <- Empty
        builder.Services.AddSingleton<DatabaseConfig>();
        builder.Services.AddHostedService<Worker>();

        var host = builder.Build();
        await host.RunAsync();
    }

    //// Old ->  Host.CreateDefaultBuilder
    //public static async Task Main(string[] args)
    //{
    //    IHost host = Host.CreateDefaultBuilder(args)
    //    .ConfigureServices((hostContext, services) =>
    //    {
    //        // https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-8/runtime#configuration-binding-source-generator
    //        IConfiguration configuration = hostContext.Configuration;
    //        IConfigurationSection section = configuration.GetSection("DatabaseConfig");

    //        // !! Configure call - to be replaced with source-gen'd implementation
    //        services.Configure<DatabaseConfig>(section);

    //        // !! Get call - to be replaced with source-gen'd implementation
    //        DatabaseConfig? configOptions0 = section.Get<DatabaseConfig>();

    //        // !! Bind call - to be replaced with source-gen'd implementation
    //        DatabaseConfig configOptions1 = new();
    //        section.Bind(configOptions1);

    //        services.AddSingleton(configOptions1);
    //        services.AddHostedService<Worker>();
    //    })
    //    .Build();
    //    await host.RunAsync();
    //}
}

public class DatabaseConfig
{
    public string ConnectionString1 { get; set; } = string.Empty;
    public string ConnectionString2 { get; set; } = string.Empty;
}

Worker:

using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace WorkerServiceTest;

public class Worker : BackgroundService
{
    private readonly ILogger<Worker> _logger;

    public Worker(ILogger<Worker> logger, DatabaseConfig databaseConfig)
    {
        Debug.Assert(databaseConfig.ConnectionString1.Equals("this"));
        Debug.Assert(databaseConfig.ConnectionString2.Equals("that"));


        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            if (_logger.IsEnabled(LogLevel.Information))
            {
                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
            }
            await Task.Delay(1000, stoppingToken);
        }
    }
}

[davidfowl]

It's because of this:

builder.Services.AddOptions<DatabaseConfig>().BindConfiguration("DatabaseConfig"); // <- Empty
builder.Services.AddSingleton<DatabaseConfig>();

That first line is setting up IOptions<DatabaseConfig> which is where configuration is being bound, and you're also adding DatabaseConfig directly. Use IOptions<DatabaseConfig> instead.

using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace WorkerServiceTest;

public class Worker : BackgroundService
{
    private readonly ILogger<Worker> _logger;

    public Worker(ILogger<Worker> logger, IOptions<DatabaseConfig> options)
    {
       var databaseConfig = options.Value;
        Debug.Assert(databaseConfig.ConnectionString1.Equals("this"));
        Debug.Assert(databaseConfig.ConnectionString2.Equals("that"));


        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            if (_logger.IsEnabled(LogLevel.Information))
            {
                _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
            }
            await Task.Delay(1000, stoppingToken);
        }
    }
}