Dependency Injection w .Net Core w aplikacji warstwowej

Cześć. Zacząłem naukę .net core i mam problem z DI. Do tej pory używałem ninjecta do wstrzykiwania zależności oraz "ładowania" kontenera z warstwy niżej.

W mojej poprzedniej aplikacji wyglądało to następująco (Klasa program metoda main oraz mój CLIModule)

internal class Program
    {
        private IMenu _menu;
        private IoHelper _ioHelper = new IoHelper();

        private ISauceService _sauceService;
        private IIngredientService _ingredientService;
        private IPizzaService _pizzaService;
        private IOrderService _orderService;
        private IClientService _clientService;

        static void Main(string[] args)
        {

            IKernel kernel = new StandardKernel(new CliModule());
            var run = kernel.Get<Program>();
            run.SetCommandMenu();

            do
            {
               run.ProgramLoop();
            } while (true);
        }

        private void ProgramLoop()
        {
            _menu.PrintAllCommands();
            _menu.Execute(Console.ReadLine());
        }

        public Program(ISauceService sauceService, IIngredientService ingredientService, IPizzaService pizzaService, IOrderService orderService, IClientService clientService,IMenu menu)
        {
            AutoMapperModel.CreateMap();

            _sauceService = sauceService;
            _pizzaService = pizzaService;
            _orderService = orderService;
            _clientService = clientService;
            _menu = menu;
            _ingredientService = ingredientService;
        }

 internal class CliModule : NinjectModule
    {
        public override void Load()
        {
            Kernel.Bind<IMenu>().To<Menu>();
            Kernel.Load(new BusinnessLogicModule());
        }
    }

Nie do końca wiem jak używa się DI w aplikacji .net core. Czytałem, że w net core DI ma własny kontener i zrobiłem coś takiego.

public class CliContainer
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddTransient<IMenu, Menu>();
        }
    }

Jednak nie wiem za bardzo jak użyć tego w metodzie main oraz jak "wstrzykiwać zależności" z warstwy niżej.

Tak na szybko napisałem bez kompilacji. Coś takiego mniej więcej

static void Main(string[] args)
        {
           
            var serviceCollection = new ServiceCollection();
            ConfigureServices(serviceCollection);
            var serviceProvider = serviceCollection.BuildServiceProvider();
            var menu=serviceProvider.GetServices<IMenu>();



        }
        public static void ConfigureServices(IServiceCollection services)
        {
            services.AddTransient<IMenu, Menu>();
            //zarejestruj wszystko
        }

Oczywiście zainstaluj Microsoft.Extensions.DependencyInjection;