Reading app configuration on startup in azure function ap

I am trying to understand how to properly configure services in Startup.cs in an Azure Function App using dotnet in the in-process model.

I have a couple of parameters in local.settings.json (and the same values when hosted in Azure)

"MyOptions:BaseAddress": "https://dev.azurewebsites.net/api/",
"MyOptions:Scope": "xxx/.default",

In an extension method I then wire this as follows:

private static IServiceCollection AddOptions(this IServiceCollection services)
{
    return services.AddOptions<MyOptions>()
        .Configure<IConfiguration>((settings, configuration) =>
        {
            configuration.GetSection(nameof(MyOptions)).Bind(settings);
        })
        .PostConfigure(opt => opt.ThrowIfValuesNotSet())
        .Services;
}

After configuring the options, I want to configure a typed http client that should use at least the base address:

services
    .AddOptions()
    .AddHttpClient<IMyService, MyService>(client =>
        {
            client.BaseAddress = <value from options>;
        }
    )

I can't really figure out how to achieve this though, and the closest I've come is just to read from the environment and not rely on my class that reads the configuration:

var baseAddress = new Uri(Environment.GetEnvironmentVariable($"{nameof(MyOptions)}:BaseAddress"));

I later use the same options in a delegating handler to manage authorization for the service being called, but there I can use DI as usual:

public class MyAuthorizationHandler : DelegatingHandler
{
    private readonly TokenCredential _credential;
    private readonly MyOptions _options;

    public MyAuthorizationHandler(TokenCredential credential, IOptions<MyOptions> options)
    {
        _credential = credential;
        _options = options.Value;
    }

    protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        var token = await _credential.GetTokenAsync(
            new TokenRequestContext(new[]
            {
                _options.Scope
            }), cancellationToken);

        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token.Token);
        return await base.SendAsync(request, cancellationToken);
    }
}

I know that I can access the IConfiguration from IFunctionsHostBuilder, but following the pattern of writing extension methods for IServiceCollection, it gets a bit cumbersome because I have to pass the IConfiguration instance along to all method calls.

Is there a recommended way of achieving this?

Update

As pointed out to me in the comments, there are many overloads when adding the http client where you can access the provider:

.AddHttpClient<IMyService, MyService>((provider, client) =>
{
    client.BaseAddress =
        new Uri(provider.GetRequiredService<MyOptions>().BaseAddress);
})

As pointed out to me in the comments, there are many overloads available when adding the http client. One of them achieves exactly what I was looking for, e.g. accessing the provider:

services
    .AddOptions()
    .AddHttpClient<IMyService, MyService>((provider, client) =>
    {
        client.BaseAddress =
            new Uri(provider.GetRequiredService<IOptions<MyOptions>>().BaseAddress);
    })

private static IServiceCollection AddOptions(this IServiceCollection services)
{
    return services.AddOptions<MyOptions>()
        .Configure<IConfiguration>((settings, configuration) =>
        {
            configuration.GetSection(nameof(MyOptions)).Bind(settings);
        })
        .PostConfigure(opt => opt.ThrowIfValuesNotSet())
        .Services;
}

Note that you must resolve your options class with IOptions<MyClass> because we added it to the service collection using AddOptions.