Esempio n. 1
0
        private static async Task HostingUsingOnlyInterfaceMethodsAsync(string[] args, CancellationToken ct)
        {
            var loggerFactory = new LoggerFactory()
                                .AddConsole(LogLevel.Trace, true);

            var logger = loggerFactory.CreateLogger <Program>();

            using (logger.BeginScope("Example:{exampleNumber}", "01"))
            {
                logger.LogInformation("Hosting an application using only interface methods");

                using (var hostBuilder = new HostBuilder("ASPNETCORE_ENVIRONMENT"))
                {
                    hostBuilder.SetLoggerFactory(loggerFactory);
                    hostBuilder.AddConfigurationBuilderHandler(param =>
                    {
                        param.Builder
                        .SetBasePath(param.Environment.ContentRootPath)
                        .AddJsonFile("appsettings.json", true, true)
                        .AddJsonFile($"appsettings.{param.Environment.Name}.json", true, true)
                        .AddEnvironmentVariables()
                        .AddCommandLine(args);
                    });
                    hostBuilder.AddConfigurationHandler(param =>
                    {
                        if (param.Environment.IsDevelopment())
                        {
                            param.Configuration["CacheTimeoutInMs"] = "1000";
                        }
                    });
                    hostBuilder.AddLoggerFactoryHandler(param =>
                    {
                        NLog.LogManager.LoadConfiguration(
                            param.Environment.ContentRootFileProvider.GetFileInfo(
                                param.Environment.IsDevelopment()
                                        ? "nlog.config"
                                        : $"nlog.{param.Environment.Name}.config")
                            .PhysicalPath);

                        param.LoggerFactory.AddNLog();
                    });
                    hostBuilder.AddServiceCollectionHandler(param =>
                    {
                        param.ServiceCollection
                        .AddOptions()
                        .Configure <ExampleHostOptions>(param.Configuration)
                        .AddSingleton(k => k.GetRequiredService <IOptions <ExampleHostOptions> >().Value);
                    });
                    hostBuilder.ServiceProviderBuilder = param =>
                    {
                        var container = new Autofac.ContainerBuilder();
                        container.Populate(param.ServiceCollection);
                        return(new AutofacServiceProvider(container.Build()));
                    };

                    using (var ctx = hostBuilder.BuildRunContext <ExampleHost>())
                    {
                        await ctx.Host.RunAsync(ct);
                    }
                }

                logger.LogInformation("Terminated");
            }
        }