Dependency Injector and choosing the a class at runtime

My simple application could, using dependency injection, log something one way or the other way. Each logger is a class, derived from an interface ILogger. The class LoggerFactory decides which logger to return to the fantasy application TheAmazingApp and then the application uses that concrete logger.

Question: how to implement this user choice, i.e. loading the proper class at run time using Autofac?

The console app below can be compiled. Observe the comment in "LoggerFactory" if you will (last class/file) - reiterating my challenge.

Main.cs

using Autofac;

namespace DepInjection
{
	internal class Program
	{
		static void Main(string[] args)
		{

			var Builder = new ContainerBuilder();

			//Start configure
			Builder.RegisterType<TheAmazingApp>();
			Builder.RegisterType<LoggerFactory>();
			Builder.RegisterType<NormalLogger>().As<ILogger>();
			Builder.RegisterType<VerboseLogger>().As<ILogger>();
			//End configure

			var Container = Builder.Build();

			using (var scope = Container.BeginLifetimeScope())
			{
				scope.Resolve<TheAmazingApp>().AmazeUs();
			}

		}
	}
}

TheAmazingApp.cs

namespace DepInjection
{
	public class TheAmazingApp
	{
		private ILogger _logger;
		public TheAmazingApp()
		{
			_logger = LoggerFactory.GetLogger();
		}

		public void AmazeUs() => _logger.Logger();
	}
}

ILogger.cs

namespace DepInjection
{
	public interface ILogger
	{
		public void Logger();
	}
}

VerboseLogger.cs

namespace DepInjection
{
	public class VerboseLogger : ILogger
	{
		public void Logger() =>	
			Console.WriteLine("Verbose Log");
	}
}

NormalLogger.cs

namespace DepInjection
{
	public class NormalLogger : ILogger
	{
		public void Logger() => 
			Console.WriteLine("Normal Log");
	}
}

LoggerFactory.cs

namespace DepInjection
{
	public class LoggerFactory
	{
		private static string? _choice;
		public static ILogger GetLogger()
		{
			//emulates the result of a user choice at run time
			_choice = "other";

			//...but how do I implement this using a dependency injector?
			return _choice == "1" ? new NormalLogger() : 
				new VerboseLogger();
		}
	}
}

There are multiple ways to solve this, but one of the most convenient methods is to create a proxy logger implementation that makes the choice, e.g.:

public class UserChoiceLogger : ILogger // This is your proxy
{
    private readonly NormalLogger normal;
    private readonly VerboseLogger verbose;

    public UserChoiceLogger(NormalLogger normal, VerboseLogger verbose)
    {
        this.normal = normal;
        this.verbose = verbose;
    }

    public void Logger()
    {
        //emulates the result of a user choice at run time
        _choice = "other";

        if (_choice == "1")
            normal.Logger();
        else
            verbose.Logger();
    }
}

Where you change TheAmazingApp to simply use constructor injection:

public class TheAmazingApp
{
    private ILogger logger;

    public TheAmazingApp(ILogger logger)
        {
        this.logger = logger;
    }

    public void AmazeUs() => logger.Logger();
}

This can be registered as follows:

var Builder = new ContainerBuilder();

//Start configure
Builder.RegisterType<TheAmazingApp>();
Builder.RegisterType<NormalLogger>();
Builder.RegisterType<VerboseLogger>();
Builder.RegisterType<UserChoiceLogger>().As<ILogger>();
//End configure

var Container = Builder.Build();

using (var scope = Container.BeginLifetimeScope())
{
    scope.Resolve<TheAmazingApp>().AmazeUs();
}

Notice how the need to have a factory deminished. Factories are often redundant.

After study it appears that the named and keyed services could provide an answer.Something like...

container.ResolveNamed<NormalLogger>("Normal") //"Normal" is returned via user input

...is possible and this gives options. Using an explicit keyed method would resemble this:

container.ResolveKeyed<NormalLogger>(Logger.Normal) //Logger.Normal is returned via user input

Haven't figured out a pretty way for the totality of the code, so I can't use this. But it's a step in the right direction. And like user @eocron mentioned, a Dep. Injector isn't really cut out for this task.