C# IConfigurationRoot类代码示例

 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 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();
 }

 public void Main(string[] args)
 {            
     Log("started with args: "+String.Join(" ", args));
                
     var configBuilder = new ConfigurationBuilder();             
         configBuilder.AddJsonFile("appsettings.json");
                                           
     Configuration = configBuilder.Build();
                 
     if (args.Contains("--windows-service"))
     {
         try
         {                    
             Log("WWWService Main()");
             Run(this); 
             return;   
         }
         catch(Exception x)
         {                    
             Log("WWWService Main() Exception: "+ x.Message);
         }
     }
     
     OnStart(null);
     Console.ReadLine();
     OnStop();                      
 }