How to transfer AppSettings to use ASP.NET Core 7's dependency injection?

I'm trying to understand how to use the code we have in ASP.NET MVC 5 with the newer ASP.NET Core 7.

From what I can tell, Core 7 no longer uses the AppSettings approach. Instead, Microsoft wants developers to use dependency injection. This is the article I am trying to follow:

https://learn.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-7.0

I see where objects are declared and used in the file Program.cs:

using DIsample2.Services;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();

builder.Services.AddScoped<Service1>();
builder.Services.AddSingleton<Service2>();

var myKey = builder.Configuration["MyKey"];
builder.Services.AddSingleton<IService3>(sp => new Service3(myKey));

var app = builder.Build();

And then the class is built differently to include the interface:

public class IndexModel : PageModel
{
    private readonly Service1 _service1;
    private readonly Service2 _service2;
    private readonly IService3 _service3;

    public IndexModel(Service1 service1, Service2 service2, IService3 service3)
    {
        _service1 = service1;
        _service2 = service2;
        _service3 = service3;
    }

    public void OnGet()
    {
        _service1.Write("IndexModel.OnGet");
        _service2.Write("IndexModel.OnGet");
        _service3.Write("IndexModel.OnGet");
    }
}

In Core 7, is this the correct way to read from a configuration file like AppSettings?

In the code above, the instantiation of PageModel is handled by the Visual Studio 2022 IDE. If I were to attempt to create a class that used services like that, I would need instances of the services to pass in. Where do I get those? It looks like Microsoft gets the services and configuration settings from var builder = WebApplication.CreateBuilder(args), but that is not something I should be accessing from classes in our code.

Here is a sample piece of code from what we have now:

public static void GetResources(SheetModel sheet)
{
    const string FMT = "No {0} File For SQL: SELECT FilePath FROM ResourceManager WHERE Category1='{1}' AND Category2='{2}' AND Category3='{3}' AND IsActive=1;";
    using (var db = new SqlEntities())
    {
        var request = new GetPreSignedUrlRequest()
        {
            BucketName = $"{ConfigurationManager.AppSettings["BucketName"]}",
            Expires = DateTime.UtcNow.AddMinutes(30),
        };
        var client = new AmazonS3Client(
            $"{ConfigurationManager.AppSettings["PublicKey"]}", 
            $"{ConfigurationManager.AppSettings["PrivateKey"]}", 
            RegionEndpoint.USEast);
        var row = db.AssetManagers.FirstOrDefault(m =>
                m.Category1 == "Sticker" &&
                m.Category2 == "Data" &&
                m.Category3 == sheet.DAMDLN &&
                m.IsActive);
        if (row != null)
        {
            request.Key = $"{row.FilePath}".Trim();
            sheet.Href = client.GetPreSignedURL(request);
        } else
        {
            Console.WriteLine(String.Format(FMT, "Data", "Sticker", "Data", sheet.DAMDLN));
        }
        row = db.AssetManagers.FirstOrDefault(m => 
            m.Category1 == "Sticker" && 
            m.Category2 == "Image" && 
            m.Category3 == sheet.DADLRN && 
            m.IsActive);
        if (row != null)
        {
            request.Key = $"{row.FilePath}".Trim();
            sheet.Image = client.GetPreSignedURL(request);
        }
        else
        {
            Console.WriteLine(String.Format(FMT, "Image", "Window Sticker", "Image", sheet.DADLRN));
        }
        row = db.AssetManagers.FirstOrDefault(m => 
            m.Category1 == "Sticker" && 
            m.Category2 == "Image" && 
            m.Category3 == "c_wreath" && 
            m.IsActive);
        if (row != null)
        {
            request.Key = $"{row.FilePath}".Trim();
            sheet.Wreath = client.GetPreSignedURL(request);
        }
        else
        {
            Console.WriteLine(String.Format(FMT, "Wreath", "Sticker", "Image", "c_wreath"));
        }
        request.Key = (row != null) ? $"{row.FilePath}".Trim() : string.Empty;
        sheet.Wreath = client.GetPreSignedURL(request);
    }
}

Would every class need to be changed to work with an interface for clients like this?

Reading from ConfigurationManager.AppSettings["SomeKey"] seemed simpler and more direct.

Can I still get to values directly, or has that door been closed?

using (var db = new SqlEntities()) - modern ASP.NET Core heavily relies on dependency injection and I highly recommend to follow this pattern, so you try not to new up or read configuration in the implementation.

The +/- quick-n-dirty approach would be to move your static method into some service, inject IConfiguration into it substituting ConfigurationManager.AppSettings with call to the injected config. For example:

appsettings.json

{
   // ....,
   "AmazonS3Client":{
      "PublicKey": "...",
      "PrivateKey": "..."
   }
}

And then in the service:

public class MyService // maybe an interface here
{
    // requires using Microsoft.Extensions.Configuration;
    private readonly IConfiguration Configuration;

    public MyService (IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public ... GetResources(...)
    {
        var publicKey = Configuration["AmazonS3Client:PublicKey"];
        var privateKey = Configuration["AmazonS3Client:PublicKey"];
        // ...
    }
}

Note that more common approach is to create a special class for settings and register it the DI and resolve the config, for example via Options pattern.
Read more:

• Configuration in ASP.NET Core - docs extensively cover the topic, including special configuration provider for storing secrets in the development environment.

• .NET 6 (stable) IConfiguration setup in Program.cs - if refactoring is too big of a job at the moment and you want static configuration approach (I would not recommend it though)