Estoy tratando de acceder a appsettings.json en mi archivo Program.cs de la aplicación Asp.net core v6, pero en esta versión de .Net, la clase de inicio y la clase de programa se fusionan y el uso y otras declaraciones se simplifican y eliminan del programa. .cs. En esta situación, ¿cómo acceder a IConfiguration o cómo usar la inyección de dependencia, por ejemplo?
Editado: aquí está mi Program.cs predeterminado que Asp.net 6 creó para mí
var builder = WebApplication.CreateBuilder(args); // Add services to the container. builder.Services.AddControllers(); builder.Services.AddStackExchangeRedisCache(options => { options.Configuration = "localhost:6379"; }); builder.Services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new() { Title = "BasketAPI", Version = "v1" }); }); var app = builder.Build(); // Configure the HTTP request pipeline. if (app.Environment.IsDevelopment()) { app.UseSwagger(); app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "BasketAPI v1")); } app.UseHttpsRedirection(); app.UseAuthorization(); app.MapControllers(); app.Run();
Por ejemplo, quiero usar appsettings.json en lugar de una cadena de conexión de tipo duro en esta línea:
options.Configuration = "localhost:6379";
Asumiendo un appsettings.json
{ "RedisCacheOptions" : { "Configuration": "localhost:6379" } }
No hay nada que le impida construir un objeto de configuración para extraer la configuración deseada.
IConfiguration configuration = new ConfigurationBuilder() .AddJsonFile("appsettings.json") .Build(); var builder = WebApplication.CreateBuilder(args); // Add services to the container. builder.Services.AddControllers(); builder.Services.AddStackExchangeRedisCache(options => { options.Configuration = configuration["RedisCacheOptions:Configuration"]; }); //...
appsettings.json está incluido de forma predeterminada, puede usarlo directamente. Si desea incluir archivos explícitamente, puede incluirlos así
builder.Configuration.AddJsonFile("errorcodes.json", false, true);
Y la inyección de dependencia como esta
builder.Services.AddDbContext<>() // like you would in older .net core projects.
Si bien los ejemplos anteriores funcionan, la forma de hacerlo es la siguiente:
var builder = WebApplication.CreateBuilder(args); // Add services to the container. builder.Services.AddControllers(); builder.Services.AddStackExchangeRedisCache(options => { options.Configuration = builder.Configuration["Redis"]; });
WebApplicationBuilder
tiene un objeto de configuración como propiedad que puede usar.
Crear una clase:
public class RedisCacheOptions { public string Configuration { get; set; } }
Y luego, en su program.cs
, haga lo siguiente:
var redisCacheOptions = new RedisCacheOptions(); builder.Configuration.GetSection(nameof(RedisCacheOptions)).Bind(redisCacheOptions);
Ahora puede acceder a la información de configuración simplemente diciendo:
redisCacheOptions.Configuration
Ahora digamos que tenía una estructura anidada en appSettings.json
así:
"AuthenticationConfiguration": { "JwtBearerConfiguration": { "Authority": "https://securetoken.google.com/somevalue", "TokenValidationConfiguration": { "Issuer": "https://securetoken.google.com/somevalue", "Audience": "somevalue" } } }
Entonces, su estructura de clase sería algo como:
public class AuthenticationConfiguration { public JwtBearerConfiguration JwtBearerConfiguration { get; set; } = new JwtBearerConfiguration(); } public class JwtBearerConfiguration { public string Authority { get; set; } public TokenValidationConfiguration TokenValidationConfiguration { get; set; } = new TokenValidationConfiguration(); } public class TokenValidationConfiguration { public string Issuer { get; set; } public string Audience { get; set; } }
Con esto, si tuvieras que hacer:
var authConf = new AuthenticationConfiguration(); builder.Configuration.GetSection(nameof(AuthenticationConfiguration)).Bind(authConf);
Luego, en su programa, podría acceder a valores como:
AuthenticationConfiguration.JwtBearerConfiguration.Authority
Este enfoque le permite eliminar las cadenas mágicas, además de obtener IntelliSense, por lo que es beneficioso para todos.
Resuelto: obtenga el valor de configuración de aplicaciones en program.css en dotnet6
appsettings.json
"AllowedHosts": "*", "ServiceUrls": { "EmployeeAPI": "https://localhost:44377/" },
Programa.cs
var builder = WebApplication.CreateBuilder(args); var provider = builder.Services.BuildServiceProvider(); var configuration = provider.GetService<IConfiguration>(); SD.EmployeeAPIBase = configuration.GetValue<string>("ServiceUrls:EmployeeAPI");
Variable estática de clase:
public static class SD //Static Details { public static string EmployeeAPIBase { get; set; } }
Finalmente, use la URL completa
URL = SD.EmployeeAPIBase + "api/EmpContact/GetGovernates"
En Program.cs, pruebe este código:
var builder = WebApplication.CreateBuilder(args); // Add services to the container. ConfigurationManager configuration = builder.Configuration; var rabbitMQSection = Configuration.GetSection("RabbitMQ"); var rabbitMQConnectionUrl = rabbitMQSection["ConnectionUrl"];
donde está el archivo appsettings.json
:
"AllowedHosts": "*", "RabbitMQ": { "ConnectionUrl": "amqp://guest:guest@localhost:5672/" }
En caso de que lo tengamos en appsettings
"settings": { "url": "myurl", "username": "guest", "password": "guest" }
y tenemos la clase
public class Settings { public string Url { get; set; } public string Username { get; set; } public string Password { get; set; } }
podemos usar también
var settings = builder.Configuration.GetSection("Settings").Get<Settings>();
var url = settings.Url;
etc....
Además de las respuestas de @dimmits y @Sarwarul Rizvi, si desea leer un par de valores de clave simple en lugar de asignarlo a un objeto complejo, puede usar:
appsettings.json
{ "Logging": { "LogLevel": { "Default": "Information", "Microsoft": "Information", "Microsoft.AspNetCore.SpaProxy": "Information", "Microsoft.Hosting.Lifetime": "Information" } }, "AllowedOrigins": "https://localhost:444/YourApplicationUri;https://localhost:7211", "ConnectionStrings": { "Default": "Connection String details" } }
programa.cs
ConfigurationManager configuration = builder.Configuration; var allowedOrigins = configuration.GetValue<string>("AllowedOrigins");
Esto se puede usar, por ejemplo, para configurar Cors
if (!String.IsNullOrEmpty(allowedOrigins)) { builder.Services.AddCors(options => { var origins = allowedOrigins.Split(";"); options.AddPolicy("CorsPolicy", policy => { policy.AllowAnyMethod() .AllowAnyHeader() .AllowCredentials() .WithOrigins(origins); }); }); }
Más tarde y debajo de app.UseRouting();
app.UseCors("CorsPolicy");
Puede leer el valor de configuración de su archivo appsettings.json
de esta manera, en Program.cs
:
var dbConnectionString = builder.Configuration.GetSection("ConnectionStrings:TestDbConnection").Value;
Teniendo en cuenta que la configuración se parece a esto en su archivo appsettings.json
:
"ConnectionStrings": { "TestDbConnection": "" }
En .NET 6
appSettings.json
{ "Authentication": { "CookieAuthentication": { "LoginPath": "/Security/Login" } }, "TestValue" : "Testing data" }
Programa.cs
var builder = WebApplication.CreateBuilder(args); var testValue = builder.Configuration.GetValue<string>("TestValue"); var cookieAuthenticationLoginPath = builder.Configuration.GetValue<string>("Authentication:CookieAuthentication:LoginPath");