También puede usar la configuración directamente. Sus configuraciones se inyectan para que pueda acceder a ellas con DI...

 private readonly IConfiguration _configuration; public MyClass(IConfiguration configuration) { _configuration = configuration; }

y luego puedes leer tu configuración...

En este caso estoy recuperando una colección...

 var myList = _configuration.GetSection("MyList").Get<List<string>>();

Así que en realidad hay dos maneras de hacer esto.

Opción 1: Clase de opciones

Tiene un archivo appsettings.json:

 { "myConfiguration": { "myProperty": true } }

Creas una Configuración POCO así:

 public class MyConfiguration { public bool MyProperty { get; set; } }

En su startup.cs tiene algo en su ConfigureServices que registra la configuración:

 public void ConfigureServices(IServiceCollection services) { services.Configure<MyConfiguration>(Configuration.GetSection("myConfiguration")); }

Luego, en su controlador/servicio, inyecta las IOptions y es utilizable.

 public class ValuesController : Controller { private readonly MyConfiguration _myConfiguration; public ValuesController(IOptions<MyConfiguration> myConfiguration) { _myConfiguration = myConfiguration.Value; } }

Personalmente, no me gusta usar IOptions porque creo que arrastra algo de basura adicional que realmente no quiero, pero puedes hacer cosas geniales como intercambio en caliente y otras cosas con eso.

Opción 2: Configuración POCO

Es casi lo mismo, pero en su método Configure Services, en su lugar, se vincula a un singleton de su POCO.

 public void ConfigureServices(IServiceCollection services) { //services.Configure<MyConfiguration>(Configuration.GetSection("myConfiguration")); services.AddSingleton(Configuration.GetSection("myConfiguration").Get<MyConfiguration>()); }

Y luego puede inyectar el POCO directamente:

 public class ValuesController : Controller { private readonly MyConfiguration _myConfiguration; public ValuesController(MyConfiguration myConfiguration) { _myConfiguration = myConfiguration; } }

Un poco simplista porque probablemente deberías usar una interfaz para hacer que las pruebas unitarias sean un poco más fáciles, pero entiendes la idea.

Principalmente tomado de aquí: http://dotnetcoretutorials.com/2016/12/26/custom-configuration-sections-asp-net-core/

Las soluciones en la parte superior requieren mucho tiempo y no son sencillas, esta es la mejor manera efectiva de hacerlo, no se necesita configuración en el inicio ni nada. Es como usar el buen Configuration.Manager.AppSettings["setting"]

Primero cree una clase como "Credencial":

 public class Credential { public string Username {get;set} public string Password {get;set;} }

Ahora que está configurado, pongamos IConfiguration en su constructor así:

 private IConfiguration _configuration; public ValuesController(IConfiguration iconfig) { _configuration = iconfig; }

¡Entonces estás listo para llamarlo!

 Credential c = new Credential(); c.UserName = _configuration.GetValue<string>("Credential:username"); c.Password = _configuration.GetValue<string>("Credential:password");

Suponiendo que su appsettings.json se vea así:

 "Credential": { "username": "myuser", "password": "mypassword" }

Espero que esto ayude a alguien.

define tu clase como

 public class MyClass{ private readonly IConfiguration _configuration; public MyClass(IConfiguration configuration) { _configuration = configuration; } public void myFunction(){ var value= _configuration.GetValue("xxx"); } }

cuando lo llamas desde cualquier otro lugar

 IConfiguration config = new ConfigurationBuilder() .AddJsonFile("appsettings.json", optional: false, reloadOnChange: false).Build(); MyClass myclass = new MyClass(config)

Si ya pasó al controlador su configuración y no desea asignar otro servicio en la configuración de inicio, puede obtener fácilmente su valor de la configuración de esta manera:

 public Startup(IConfiguration configuration) { Configuration = configuration; var myProperty = _configuration.GetSection("MyConfiguration")["MyProperty"]; }

utilizando la propiedad del diccionario.

Disfrutar

1. Agregue esto en el archivo AppSettings.json
   "Swagger": { "Title": "API DEVELOPMENT" }

2. Luego configure eso en el archivo Startup.cs

    public Startup(IConfiguration configuration) { Configuration = configuration; } public IConfiguration Configuration { get; }

3. A continuación, obtenga el valor de appsettings.json

    var title = Configuration.GetSection("Swagger:Title").Value;

4. Finalmente poner aquí

    services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new OpenApiInfo { Title = title, Version = "v1" }); }

Adición a la respuesta de @MindingData. Me gusta mapear mi configuración recursivamente usando Configuration.Bind(settings); para que no tenga que agregar cada nueva sección en ConfigureServices .

Ejemplo:

configuración de aplicaciones.json:

 { "MyConfiguration": { "MyProperty": true } }

Clase de configuración, las propiedades deben coincidir con los nombres de appsettings.json :

 public class Settings { public MyConfigurationSettings MyConfiguration { get; set; } public class MyConfigurationSettings { public bool MyProperty { get; set; } } }

Inicio.cs

 public class Startup { public Startup(IConfiguration configuration) { Configuration = configuration; } public IConfiguration Configuration { get; } // This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { var settings = new Settings(); Configuration.Bind(settings); services.AddSingleton(settings); ...

Se puede usar en controladores como este:

 [Route("api/[controller]")] [ApiController] public class ValuesController : ControllerBase { private readonly Settings _settings; public ValuesController(Settings settings) { _settings = settings; } [HttpGet("GetValue")] public ActionResult<string> Get() { return Ok(_settings.MyConfiguration.MyProperty); } }