c# - ioptions - net core web config

Obteniendo valor de appsettings.json en.net core

Question

No estoy seguro de qué me estoy perdiendo aquí, pero no puedo obtener los valores de mi appsettings.json en mi aplicación .net core. Tengo mi appsettings.json como:

{
    "AppSettings": {
        "Version": "One"
    }
}

Puesta en marcha:

public class Startup
{
    private IConfigurationRoot _configuration;
    public Startup(IHostingEnvironment env)
    {
        _configuration = new ConfigurationBuilder()
    }
    public void ConfigureServices(IServiceCollection services)
    {
      //Here I setup to read appsettings        
      services.Configure<AppSettings>(_configuration.GetSection("AppSettings"));
    }
}

Modelo:

public class AppSettings
{
    public string Version{ get; set; }
}

Controlador:

public class HomeController : Controller
{
    private readonly AppSettings _mySettings;

    public HomeController(IOptions<AppSettings> settings)
    {
        //This is always null
        _mySettings = settings.Value;
    }
}

_mySettings siempre es nulo. ¿Hay algo que me estoy perdiendo aquí?

Answer 1

Core 2.0

No necesita una nueva IConfiguration de IConfiguration en el constructor de Startup . Su implementación será inyectada por el sistema DI.

Program.cs

public class Program
{
    public static void Main(string[] args)
    {
        BuildWebHost(args).Run();
    }

    public static IWebHost BuildWebHost(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup<Startup>()
            .Build();            
}

Startup.cs

public class Startup
{
    public IHostingEnvironment HostingEnvironment { get; private set; }
    public IConfiguration Configuration { get; private set; }

    public Startup(IConfiguration configuration, IHostingEnvironment env)
    {
        this.HostingEnvironment = env;
        this.Configuration = configuration;
    }
}

Prima:

Si separa su solución en múltiples proyectos con el uso de bibliotecas de clases, el paquete Microsoft.Extensions.Options.ConfigurationExtensions es útil para leer los valores de los archivos de appsettings aplicaciones e inyectarlos en sus clases de configuración dentro de los proyectos.

Tiene 2 extensiones que puedes usar:

public static T Get<T>(this IConfiguration configuration);
public static IServiceCollection Configure<TOptions>(this IServiceCollection services, 
    IConfiguration config) where TOptions : class;

Ejemplo:

Puse todos los servicios relacionados con la seguridad usando Microsoft.AspNetCore.Identity en su propio proyecto llamado DL.SO.Services.Security .

Configuración de seguridad en appsettings.json

Defino configuraciones, llamadas "AppIdentitySettings", para las opciones de identidad que quiero configurar en el marco de ASP.NET Core Identity en mi proyecto web / de inicio.

{
    "ConnectionStrings": {
        ...
    },
    "AppIdentitySettings": {
        "User": {
            "RequireUniqueEmail": true
        },
        "Password": {
            "RequiredLength": 6,
            "RequireLowercase": true,
            "RequireUppercase": true,
            "RequireDigit": true,
            "RequireNonAlphanumeric": true
        },
        "Lockout": {
            "AllowedForNewUsers": true,
            "DefaultLockoutTimeSpanInMins": 30,
            "MaxFailedAccessAttempts": 5
        }
    },
    "Recaptcha": {
        ...
    },
    ...
}

Clases de configuracion

Luego, debe definir las clases de configuración, que son solo POCO, para representar su estructura de configuración en appsettings.json . El nombre de la clase de configuración no tiene que coincidir con el nombre de la sección que defina en appsettings.json , sino que los nombres de las propiedades deben coincidir.

namespace DL.SO.Services.Security
{
    public class AppIdentitySettings
    {
        public UserSettings User { get; set; }
        public PasswordSettings Password { get; set; }
        public LockoutSettings Lockout { get; set; }
    }

    public class UserSettings
    {
        public bool RequireUniqueEmail { get; set; }
    }

    public class PasswordSettings
    {
        public int RequiredLength { get; set; }
        public bool RequireLowercase { get; set; }
        public bool RequireUppercase { get; set; }
        public bool RequireDigit { get; set; }
        public bool RequireNonAlphanumeric { get; set; }
    }

    public class LockoutSettings
    {
        public bool AllowedForNewUsers { get; set; }
        public int DefaultLockoutTimeSpanInMins { get; set; }
        public int MaxFailedAccessAttempts { get; set; }
    }
}

Método de extensión

Puede configurar el enlace entre appsettings.json y esas clases de configuración en el Startup de su proyecto web. Pero prefiero definir métodos de extensión en el proyecto separado para que pueda enchufar y jugar.

using DL.SO.Services.Security.Entities;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

namespace DL.SO.Services.Security.Extensions
{
    public static class ServiceCollectionExtensions
    {
        public static void AddIdentitySecurityService(this IServiceCollection services, 
            IConfiguration configuration)
        {
            string connectionString = configuration.GetConnectionString("AppDbConnection");
            string assemblyNamespace = typeof(AppIdentityDbContext).Namespace;

            var settingsSection = configuration.GetSection("AppIdentitySettings");
            var settings = settingsSection.Get<AppIdentitySettings>();

            // Inject AppIdentitySettings so that others can use too
            services.Configure<AppIdentitySettings>(settingsSection);

            services.AddDbContext<AppIdentityDbContext>(options =>
                options.UseSqlServer(connectionString, optionsBuilder =>
                    optionsBuilder.MigrationsAssembly(assemblyNamespace)
                )
            );

            services.AddIdentity<AppUser, AppRole>(options =>
            {
                // User settings
                options.User.RequireUniqueEmail = settings.User.RequireUniqueEmail;

                // Password settings
                options.Password.RequireDigit = settings.Password.RequireDigit;
                options.Password.RequiredLength = settings.Password.RequiredLength;
                options.Password.RequireLowercase = settings.Password.RequireLowercase;
                options.Password.RequireNonAlphanumeric = settings.Password.RequireNonAlphanumeric;
                options.Password.RequireUppercase = settings.Password.RequireUppercase;

                // Lockout settings
                options.Lockout.AllowedForNewUsers = settings.Lockout.AllowedForNewUsers;
                options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(settings.Lockout.DefaultLockoutTimeSpanInMins);
                options.Lockout.MaxFailedAccessAttempts = settings.Lockout.MaxFailedAccessAttempts;
            })
            .AddEntityFrameworkStores<AppIdentityDbContext>()
            .AddDefaultTokenProviders();
        }
    }
}

Conectarse al inicio principal

namespace DL.SO.Web.UI
{
    ...

    public void ConfigureServices(IServiceCollection services)
    {
        // Configure ASP.NET Core Identity
        services.AddIdentitySecurityService(this.Configuration);

        ...
    }
}

Core 1.x

Debe indicarle a Startup que cargue los archivos de configuración de la aplicación.

Program.cs

public class Program
{
    public static void Main(string[] args)
    {
        var host = new WebHostBuilder()
            .UseKestrel()
            .UseContentRoot(Directory.GetCurrentDirectory())
            .UseIISIntegration()
            .UseStartup<Startup>()
            .UseApplicationInsights()
            .Build();

        host.Run();
    }
}

Startup.cs

public class Startup
{
    public IConfigurationRoot Configuration { get; private set; }

    public Startup(IHostingEnvironment env)
    {
        var builder = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
            .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
            .AddEnvironmentVariables();

        this.Configuration = builder.Build();
    }
    ...
}

¡Gracias @Kirk por señalarlo!

Answer 2

Agregando a la respuesta de David Liang para Core 2.0 -

appsettings.json archivos appsettings.json están vinculados a la variable ASPNETCORE_ENVIRONMENT .

ASPNETCORE_ENVIRONMENT se puede establecer en cualquier valor, pero el marco admite tres valores: Development , Staging y Production . Si ASPNETCORE_ENVIRONMENT no está configurado, el valor predeterminado será Production .

Para estos tres valores, estos archivos appsettings.ASPNETCORE_ENVIRONMENT.json son compatibles de appsettings.Staging.json : appsettings.Staging.json , appsettings.Development.json y appsettings.Production.json

Los tres archivos json de configuración de aplicaciones anteriores se pueden usar para configurar múltiples entornos.

Ejemplo: appsettings.Staging.json

{
    "Logging": {
        "IncludeScopes": false,
        "LogLevel": {
            "System": "Information",
            "Microsoft": "Information"
        }
    },
    "MyConfig": "My Config Value for staging."
}

Use la Configuration["config_var"] para recuperar cualquier valor de configuración.

public class Startup
{
    public Startup(IHostingEnvironment env, IConfiguration config)
    {
        Environment = env;
        Configuration = config;
        var myconfig = Configuration["MyConfig"];
    }

    public IConfiguration Configuration { get; }
    public IHostingEnvironment Environment { get; }
}

Answer 3

En el constructor de la clase Startup, puede acceder a appsettings.json y muchas otras configuraciones utilizando el objeto inyectado IConfiguration:

Startup.cs Constructor

    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;

        //here you go
        var myvalue = Configuration["Grandfather:Father:Child"];

    }

public IConfiguration Configuration { get; }

Contenido de appsettings.json

  {
  "Grandfather": {
    "Father": {
      "Child": "myvalue"
    }
  }

Answer 4

En mi caso, era simple como usar el método Bind () en el objeto Configuration. Y luego agregue el objeto como singleton en el DI.

var instructionSettings = new InstructionSettings();
Configuration.Bind("InstructionSettings", instructionSettings);
services.AddSingleton(typeof(IInstructionSettings), (serviceProvider) => instructionSettings);

El objeto Instrucción puede ser tan complejo como desee.

{  
 "InstructionSettings": {
    "Header": "uat_TEST",
    "SVSCode": "FICA",
    "CallBackUrl": "https://UATEnviro.companyName.co.za/suite/webapi/receiveCallback",
    "Username": "s_integrat",
    "Password": "X@nkmail6",
    "Defaults": {
    "Language": "ENG",
    "ContactDetails":{
       "StreetNumber": "9",
       "StreetName": "Nano Drive",
       "City": "Johannesburg",
       "Suburb": "Sandton",
       "Province": "Gauteng",
       "PostCode": "2196",
       "Email": "[email protected]",
       "CellNumber": "0833 468 378",
       "HomeNumber": "0833 468 378",
      }
      "CountryOfBirth": "710"
    }
  }

Answer 5

Simplemente cree un archivo AnyName.cs y pegue el siguiente código.

using System;
using System.IO;
using Microsoft.Extensions.Configuration;

namespace Custom
{
    static class ConfigurationManager
    {
        public static IConfiguration AppSetting { get; }
        static ConfigurationManager()
        {
            AppSetting = new ConfigurationBuilder()
                    .SetBasePath(Directory.GetCurrentDirectory())
                    .AddJsonFile("YouAppSettingFile.json")
                    .Build();
        }
    }
}

Debe reemplazar el nombre del archivo YouAppSettingFile.json con su nombre de archivo.
Su archivo .json debería verse a continuación.

{
    "GrandParent_Key" : {
        "Parent_Key" : {
            "Child_Key" : "value1"
        }
    },
    "Parent_Key" : {
        "Child_Key" : "value2"
    },
    "Child_Key" : "value3"
}

Ahora puedes usarlo.
No olvide agregar referencia en su clase donde quiera usar.

using Custom;

Código para recuperar valor.

string value1 = ConfigurationManager.AppSetting["GrandParent_Key:Parent_Key:Child_Key"];
string value2 = ConfigurationManager.AppSetting["Parent_Key:Child_Key"];
string value3 = ConfigurationManager.AppSetting["Child_Key"];

Answer 6

Supongo que la forma más simple es por DI. Un ejemplo de llegar al controlador.

// StartUp.cs
public void ConfigureServices(IServiceCollection services)
{
    ...
    // for get appsettings from anywhere
    services.AddSingleton(Configuration);
}

public class ContactUsController : Controller
{
    readonly IConfiguration _configuration;

    public ContactUsController(
        IConfiguration configuration)
    {
        _configuration = configuration;

        // sample:
        var apiKey = _configuration.GetValue<string>("SendGrid:CAAO");
        ...
    }
}

Answer 7

    public static void GetSection()
    {
        Configuration = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("appsettings.json")
            .Build();

        string BConfig = Configuration.GetSection("ConnectionStrings")["BConnection"];

    }