public HomeController(IConfigurationRoot configuration, IOptions<OtherSettings> otherSettings, ILogger<HomeController> logger, IMemoryCache memoryCache)
 {
     _configuration = configuration;
     _otherSettings = otherSettings.Value;
     _logger = logger;
     _memoryCache = memoryCache;
 }

        public void ConfigureServices(IServiceCollection services, IConfigurationRoot configuration)
        {
            services.AddEntityFramework()
              .AddSqlServer()
              .AddDbContext<ApplicationDbContext>(options =>
                    options.UseSqlServer(configuration["Data:DefaultConnection:ConnectionString"]));

            services.AddIdentity<ApplicationUser, IdentityRole>()
                .AddEntityFrameworkStores<ApplicationDbContext>()
                .AddDefaultTokenProviders();

            // Add framework services.
            services.AddMvc().AddJsonOptions(options =>
            {
                options.SerializerSettings.ContractResolver =
                    new CamelCasePropertyNamesContractResolver();
            });

            // Add CORS support
            services.AddCors(options =>
            {
                options.AddPolicy("AllowAllOrigins",
                    builder => builder.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod());
            });

            services.AddScoped<IUsersRepository, AspNetIdentityUsersRepository>();
            services.AddScoped<IUserClaimsRepository, AspNetIdentityUserClaimsRepository>();
        }

 public static ILoggerFactory AddNLog(this ILoggerFactory factory, IConfigurationRoot configuration)
 {
     LogManager.AddHiddenAssembly(typeof (AspNetExtensions).GetTypeInfo().Assembly);
     factory.AddProvider(new NLogLoggerProvider());
     LogManager.Configuration = new XmlLoggingConfiguration(configuration[NLogConfigurationPathKey], true);
     return factory;
 }

        public FunContext(IConfigurationRoot config)
        {
            _config = config;

              Database.EnsureCreated();
              Database.Migrate();
        }

 public AuthMiddlewarePlugin(IConfigurationRoot configurationRoot)
 {
     _configurationRoot = configurationRoot;
     Area = _configurationRoot["Filters:Configuration:AuthActionFilter:Area"];
     Controller = _configurationRoot["Filters:Configuration:AuthActionFilter:Controller"];
     Action = _configurationRoot["Filters:Configuration:AuthActionFilter:Action"];
 }

        public static ILifetimeScope CreateAutofacContainer(this IServiceCollection services, IConfigurationRoot configuration)
        {
            var builder = new ContainerBuilder();

            // Load web specific dependencies
            builder.RegisterType<AuthMessageSender>()
                .As<IEmailSender>().InstancePerLifetimeScope();
            builder.RegisterAssemblyTypes(typeof(Startup).GetTypeInfo().Assembly).AsImplementedInterfaces();
            builder.RegisterAssemblyTypes(typeof (CartCommandService).GetTypeInfo().Assembly, typeof (ICartCommandService).GetTypeInfo().Assembly)
                .AsImplementedInterfaces();

            var databaseInitializer = new MigrateToLatestVersion(new SampleDataSeeder());
            builder.AddDataOnion(new DbContextConfig(configuration.GetConnectionString("DefaultConnection"), typeof(MusicStoreContext), databaseInitializer));

            // Populate the container with services that were previously registered
            builder.Populate(services);

            builder.RegisterType<BaseRepository<Album, MusicStoreContext>>().As<IRepository<Album>>();
            builder.RegisterType<BaseRepository<Artist, MusicStoreContext>>().As<IRepository<Artist>>();
            builder.RegisterType<BaseRepository<Cart, MusicStoreContext>>().As<IRepository<Cart>>();
            builder.RegisterType<BaseRepository<CartItem, MusicStoreContext>>().As<IRepository<CartItem>>();
            builder.RegisterType<BaseRepository<Genre, MusicStoreContext>>().As<IRepository<Genre>>();
            builder.RegisterType<BaseRepository<Order, MusicStoreContext>>().As<IRepository<Order>>();
            builder.RegisterType<BaseRepository<OrderDetail, MusicStoreContext>>().As<IRepository<OrderDetail>>();

            var container = builder.Build();

            return container;
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="spoAuthorization"></param>
 /// <param name="generalSettings"></param>
 /// <param name="searchSettings"></param>
 public Search(ISPOAuthorization spoAuthorization,
     IConfigurationRoot configuration,
     ICustomLogger customLogger,
     IUsersDetails userDetails,
     ISPList spList,
     IOptions<GeneralSettings> generalSettings,
     IOptions<SharedSettings> sharedSettings,
     IOptions<LogTables> logTables,
     IOptions<SearchSettings> searchSettings,
     IOptions<CamlQueries> camlQueries,
     IOptions<ListNames> listNames,
     IOptions<ErrorSettings> errorSettings)
 {
     this.spoAuthorization = spoAuthorization;
     this.generalSettings = generalSettings.Value;
     this.searchSettings = searchSettings.Value;
     this.userDetails = userDetails;
     this.customLogger = customLogger;
     this.logTables = logTables.Value;
     this.spList = spList;
     this.camlQueries = camlQueries.Value;
     this.listNames = listNames.Value;
     this.sharedSettings = sharedSettings.Value;
     this.errorSettings = errorSettings.Value;
     this.configuration = configuration;
 }

 public AzureEndpoints(IConfigurationRoot configuration)
 {
     DocumentDBUrl = configuration["APPSETTING_ddburl"];
     DocumentDBKey = configuration["APPSETTING_ddbkey"];
     SearchAccount = configuration["APPSETTING_searchaccount"];
     SearchKey = configuration["APPSETTING_searchkey"];
 }

        private static void FrontLoadFilterItems(IConfigurationRoot configurationRoot)
        {
            /*

            var filterItem = CreateFilterItem(settings.Value.Authorization.Filter);
            TypeToFilterItem.Add(settings.Value.Authorization.Filter, filterItem);

            if (settings.Value.SimpleMany != null)
            {
                if (settings.Value.SimpleMany.OptOut != null)
                {
                    foreach (var record in settings.Value.SimpleMany.OptOut)
                    {
                        filterItem = CreateFilterItem(record.Filter);
                        TypeToFilterItem.Add(record.Filter, filterItem);
                    }
                }

                if (settings.Value.SimpleMany.OptIn != null)
                {
                    foreach (var record in settings.Value.SimpleMany.OptIn)
                    {
                        filterItem = CreateFilterItem(record.Filter);
                        TypeToFilterItem.Add(record.Filter, filterItem);
                    }
                }
            }
            */
        }

 public static IServiceCollection AddCloudFoundry(this IServiceCollection serviceCollection,
     IConfigurationRoot configuration)
 {
     string vcapRaw = configuration.GetSection("VCAP_SERVICES").Value;
     Dictionary<String, BoundService> results = new Dictionary<string, BoundService>();
     VcapParser parser = new VcapParser();
     
     if (!string.IsNullOrEmpty(vcapRaw))
     {
         try
         {
             results = parser.ParseConfigurationForVcap(vcapRaw);
         }
         catch (Exception ex)
         {
             throw new ArgumentException("VCAP_SERVICES", "Could not parse VCAP_SERVICES environment variable or other substitute configuration. Cannot enable cloud foundry configuration.", ex);
         }
     }
    
     serviceCollection.Configure<CloudFoundryBoundServiceOptions>(options =>
     {
         options.BoundServices = results;
     });
     
     return serviceCollection;
 }

 public AuthAjaxActionFilter(IConfigurationRoot configurationRoot)
 {
     _configurationRoot = configurationRoot;
     Area = _configurationRoot["Filters:Configuration:AuthActionFilter:Area"];
     Controller = _configurationRoot["Filters:Configuration:AuthActionFilter:Controller"];
     Action = _configurationRoot["Filters:Configuration:AuthActionFilter:Action"];
 }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IConfigurationRoot configuration)
        {
            loggerFactory.AddConsole(configuration.GetSection("Logging"));
            loggerFactory.AddDebug();

            // For more details on creating database during deployment see http://go.microsoft.com/fwlink/?LinkID=615859
            try
            {
                using (var serviceScope = app.ApplicationServices.GetRequiredService<IServiceScopeFactory>()
                    .CreateScope())
                {
                    using (var db = serviceScope.ServiceProvider.GetService<ApplicationDbContext>())
                    {
                        db.Database.EnsureCreated();
                        db.Database.Migrate();
                    }
                }
            }
            catch (Exception exception)
            {
            }

            app.UseCors("AllowAllOrigins");         // TODO: allow collection of allowed origins per client
            app.UseIISPlatformHandler();
            app.UseStaticFiles();
            app.UseMvc();
        }

 public ConfigController(IConfigurationRoot configuration, IApplicationEnvironment appEnv)
 {
     this.configuration = configuration;
     string applicationPath = appEnv.ApplicationBasePath;
     settings_file = Path.Combine(applicationPath, SETTINGS_FILE_NAME);
     project_file = Path.Combine(applicationPath, "project.json");
 }

 public AccountController(IConfigurationRoot appSettings, UserManager<ApplicationUser> userManager, SignInManager<ApplicationUser> signInManager, ILoggerFactory loggerFactory)
 {
     _appSettings = appSettings;
     _userManager = userManager;
     _signInManager = signInManager;
     _logger = loggerFactory.CreateLogger<AccountController>();
 }

 public static IServiceCollection BuildConfiguration(this IServiceCollection services,
     IConfigurationRoot configuration)
 {
     AssemblyApi.AssemblyManager.Initialize(configuration);
     services.Configure<ServerOptions>(configuration.GetSection("ServerOptions"));
     return services;
 }

        public void Run()
        {
            try
              {
            Console.WriteLine("Reading Configuration");
            var builder = new ConfigurationBuilder()
             .SetBasePath(PlatformServices.Default.Application.ApplicationBasePath)
             .AddJsonFile("config.json")
             .AddEnvironmentVariables();

            _config = builder.Build();
            _ctx = new OldWilderContext(_config);
            _newCtx = new WilderContext(_config);
            _repo = new WilderRepository(_config, _newCtx);

            Console.WriteLine("Migrating Stories");
            MigrateStories();

            //TODO More migration

              }
              catch (Exception ex)
              {
            Console.WriteLine(ex.ToString());
            Console.ReadKey();
              }
        }

 /// <summary>
 /// インスタンスを生成します。
 /// </summary>
 /// <param name="env"></param>
 public Startup(IHostingEnvironment env)
 {
     this.Configuration = new ConfigurationBuilder()
                         .AddJsonFile("appsettings.json")
                         .AddEnvironmentVariables()
                         .Build();
 }

 public UmbracoConfig(IApplicationEnvironment appEnv)
 {
     var cfg = new ConfigurationBuilder()
         .SetBasePath(appEnv.ApplicationBasePath)
         .AddJsonFile("umbraco.json");
     _config = cfg.Build();
 }

 public Startup(IHostingEnvironment env, IApplicationEnvironment appEnv)
 {
     var builder = new ConfigurationBuilder()
         .SetBasePath(appEnv.ApplicationBasePath)
         .AddJsonFile("config.json");
     Configuration = builder.Build();
 }

 public Startup(IHostingEnvironment env)
 {
     var builder = new ConfigurationBuilder()
         .AddJsonFile("appsettings.json")
         .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);
     Configuration = builder.Build();
 }