cli-ninject-hosting/CustomHostingDemo/Program.cs

using CustomHostingDemo.Logging;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using Ninject;
using Ninject.Syntax;
using System;
using System.CommandLine;
using System.CommandLine.Binding;
using System.CommandLine.Builder;
using System.CommandLine.Invocation;
using System.CommandLine.Parsing;
using System.IO;
using System.Linq;
using System.Reflection;

namespace CustomHostingDemo
{
    class Program
    {
        static int Main(string[] args)
        {
            var kernel = new StandardKernel();

            var config = new ConfigurationBuilder()
                .SetBasePath(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location))
                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
                .AddJsonFile(Path.Combine(Environment.GetEnvironmentVariable("USERPROFILE"), "custom-demo.json"), optional: true, reloadOnChange: false)
                .Build();

            kernel.Bind<IConfiguration>().ToConstant(config).InSingletonScope();
            kernel.Bind<ILoggerFactory>().To<LoggerFactory>().InSingletonScope();
            kernel.Bind(typeof(Logger<>)).ToSelf().InSingletonScope();
            kernel.Bind<ILoggerProvider>().To<LoggerProvider>().InSingletonScope();
            kernel.Bind<ILog>().To<Log>().InTransientScope();

            kernel.Bind<InvocationContext>().ToMethod(ctx =>
            {
                var parameter = ctx.Parameters.FirstOrDefault(p => p.Name == nameof(InvocationContext));
                if (parameter == null)
                {
                    throw new Exception("Cannot resolve InvocationContext outside of an actual NinjectCommandHandler invocation");
                }

                return (InvocationContext)parameter.GetValue(ctx, null);
            });

            Console.WriteLine($"Hello {config["Hello"]}");

            var logger = kernel.Get<Logger<Program>>();
            logger.LogInformation("Informational Message");
            logger.LogWarning("Ooopsie!");

            var rootCommand = new RootCommand()
            {
                new HelloCommand().Bind(kernel),
            };

            var parser = new CommandLineBuilder(rootCommand)
                //.UseMiddleware((invocationContext) =>
                //{
                //    var cmdArgs = new HelloCommand.HelloArgs();
                //    var binder = new ModelBinder<HelloCommand.HelloArgs>();
                //    binder.UpdateInstance(cmdArgs, invocationContext.BindingContext);

                //    kernel.Bind<HelloCommand.HelloArgs>().ToConstant(cmdArgs).InSingletonScope();

                //    //invocationContext.BindingContext.AddService(typeof(HelloCommand.HelloArgs), () => cmdArgs);
                //    invocationContext.BindingContext.AddService(typeof(HelloCommand.DefaultHandler), () =>
                //    {
                //        var handler = kernel.Get<HelloCommand.DefaultHandler>();
                //        return handler;
                //    });
                //})
                .UseDefaults()
                .Build();

            return parser.InvokeAsync(args).Result;
        }
    }
}