web-dev-qa-db-fra.com

Obtenir la valeur de appsettings.json dans le noyau .net

Je ne sais pas ce qui me manque, mais je ne parviens pas à obtenir les valeurs de mon appsettings.json dans mon application .net. J'ai mon appsettings.json comme:

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

Commencez:

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

Modèle:

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

Manette:

public class HomeController : Controller
{
    private readonly AppSettings _mySettings;

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

_mySettings est toujours nul. Y a-t-il quelque chose qui me manque ici?

c#asp.net-coreasp.net-core-mvc
61
aman

Core 2.0

Vous n'avez pas besoin de new IConfiguration dans le constructeur Startup. Sa mise en œuvre sera injectée par le système 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;
    }
}

Prime:

Si vous séparez votre solution en plusieurs projets avec l'utilisation de bibliothèques de classes, Microsoft.Extensions.Options.ConfigurationExtensions package est pratique pour lire les valeurs des fichiers appsettings et les injecter dans vos classes de configuration au sein de projets.

Il a 2 extensions que vous pouvez utiliser:

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

Exemple:

J'ai mis tous les services liés à la sécurité utilisant Microsoft.AspNetCore.Identity dans son propre projet appelé DL.SO.Services.Security. 

Paramètres de sécurité dans appsettings.json

Je définis des configurations, appelées "AppIdentitySettings", pour les options d’identité que je souhaite configurer dans le cadre ASP.NET Core Identity de mon projet Web/démarrage.

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

Classes de configuration

Ensuite, vous devez définir des classes de configuration, qui ne sont que des POCO, pour représenter votre structure de configuration dans appsettings.json. Le nom de la classe de configuration ne doit pas nécessairement correspondre au nom de la section que vous définissez dans le appsettings.json, mais les noms des propriétés doivent correspondre. 

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éthode d'extension

Vous pouvez configurer la liaison entre appsettings.json et ces classes de configuration dans Startup de votre projet Web. Mais je préfère définir des méthodes d'extension dans le projet séparé afin que vous puissiez plug-and-play.

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

Branchez-vous au démarrage principal 

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

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

        ...
    }
}

Core 1.x

Vous devez indiquer à Startup de charger les fichiers appsettings.

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

Merci @Kirk pour l'avoir signalé!

85
David Liang

Ajout à la réponse de David Liang pour Core 2.0 - 

Les fichiers appsettings.json sont liés à la variable ASPNETCORE_ENVIRONMENT.

ASPNETCORE_ENVIRONMENT peut être défini sur n'importe quelle valeur, mais le cadre prend en charge trois valeurs: Development, Staging et Production. Si ASPNETCORE_ENVIRONMENT n'est pas défini, la valeur par défaut sera Production.

Pour ces trois valeurs, les fichiers appsettings.ASPNETCORE_ENVIRONMENT.json sont pris en charge immédiatement - appsettings.Staging.json, appsettings.Development.json et appsettings.Production.json

Les trois fichiers json de réglage d'application ci-dessus peuvent être utilisés pour configurer plusieurs environnements.

Exemple - appsettings.Staging.json 

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

UtilisezConfiguration["config_var"]pour récupérer une valeur de configuration.

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; }
}
29
Aseem Gautam

Créez simplement un fichier AnyName.cs et collez le code suivant.

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

Doit remplacer le nom de fichier YouAppSettingFile.json par votre nom de fichier.
Votre fichier .json devrait ressembler à celui ci-dessous.

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

Maintenant, vous pouvez l'utiliser.
N'oubliez pas de Ajouter une référence dans votre classe où vous souhaitez utiliser.

using Custom;

Code pour récupérer la valeur.

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

Je suppose que le moyen le plus simple est de DI. Un exemple d'atteinte dans le contrôleur.

// 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");
        ...
    }
}
8
harveyt

Dans le constructeur de la classe Startup, vous pouvez accéder à appsettings.json et à de nombreux autres paramètres à l'aide de l'objet IConfiguration injecté:

Constructeur Startup.cs 

    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;

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

    }

public IConfiguration Configuration { get; }

Contenu de appsettings.json

  {
  "Grandfather": {
    "Father": {
      "Child": "myvalue"
    }
  }
3
Shadi Namrouti
    public static void GetSection()
    {
        Configuration = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("appsettings.json")
            .Build();

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

    }
2
sepideh dalirpour

Dans mon cas, il était simple d'utiliser la méthode Bind () sur l'objet Configuration. Et ajoutez ensuite l'objet en tant que singleton dans la DI.

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

L'objet Instruction peut être aussi complexe que vous le souhaitez.

{  
 "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"
    }
  }
0
Lizo Matala