Dependency Injection ASP.NET Core: Register multiple implementations

You could do it using factory:

So first you need to define your 2 services:

services.AddScoped<Service1>();
services.AddScoped<Service2>();

services.AddScoped<Func<int, IContractService>>(serviceProvider=> key=>
{
    switch(key)
    {
        case 1:
           return serviceProvider.GetService<Service1>();
        case 2:
           return serviceProvider.GetService<Service2>();
        default:
            throw new Exception("Not valid key");
    }
});

Here docs.microsoft for GetService, you could use some kind of enumeration instead of plain int

After that in your controller:

public class HomeController:Controller
{

    private readonly Service1 _service1;   

    public HomeController(Func<int, IContractService> serviceProvider)
    {
        _service1 = serviceProvider(1);            
    }

}

The default out of the box DI is too simple for such complex registrations. It was meant to serve the basic needs of the framework and most consumer apps built on it.

So your desired functionality is not available by default.

The framework however, allows you to use your preferred well featured containers and replace the default one.

The official documentation provides an example here

Dependency injection in ASP.NET Core: Default service container replacement

Another option could be change up the design to be a little more explicit and SOLID

interface IContractService{}

interface IContractService1: IContractService{}

interface IContractService2: IContractService{}

class ContractService1 : IContractService1{}

class ContractService2 : IContractService2{}

class ContractServiceFactory {
    private readonly IServiceProvider _serviceProvider;

    public ContractServiceFactory(IServiceProvider serviceProvider) {
        _serviceProvider = serviceProvider;            
    }

    public IContractService GetContractService(string standard) {
        switch(standard) {
            case "standard1" :
                return _serviceProvider.GetRequiredService<IContractService1>();
                break;
            case "standard2" :
                return _serviceProvider.GetRequiredService<IContractService2>();
                break;
            case .....
        }
    }
}

And you register services accordingly

builder.Services.AddScoped<IContractService1, ContractService1>();
builder.Services.AddScoped<IContractService2, ContractService2>();

I found the following alternative:

Let's say we have a class which uses both types:

class Foo
{
    public Foo(IContractService contractService1, IContractService contractService2)
    {
     ...
    }
}

You can register the services like this (without specifying the interface):

builder.Services.AddScoped<ContractService1>();
builder.Services.AddScoped<ContractService2>();

And then register the types that needs them like this (example for above Foo class):

 builder.Services.AddScoped<Foo>(sp => new Foo(sp.GetService<ContractService1>, sp.GetService<ContractService2>));