wake-up-neo.com

Wert von appsettings.json im .net-Core abrufen

Ich weiß nicht, was ich hier vermisse, aber ich kann die Werte nicht aus meiner appsettings.json in meiner .net-Kernanwendung abrufen. Ich habe meine appsettings.json als:

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

Anlaufen:

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

Modell:

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

Regler:

public class HomeController : Controller
{
    private readonly AppSettings _mySettings;

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

_mySettings ist immer null. Gibt es etwas, was ich hier vermisse?

61
aman

Core 2.0

Sie müssen im Konstruktor IConfiguration keine neue Variable Startup eingeben. Seine Implementierung wird vom DI-System eingespritzt.

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

Bonus:

Wenn Sie Ihre Lösung mithilfe von Klassenbibliotheken in mehrere Projekte aufteilen, ist Microsoft.Extensions.Options.ConfigurationExtensions package praktisch, um die Werte aus appsettings-Dateien zu lesen und sie in Ihre Konfigurationsklassen innerhalb von Projekten einzufügen.

Es gibt 2 Erweiterungen, die Sie verwenden können:

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

Beispiel:

Ich habe alle sicherheitsrelevanten Dienste mit Microsoft.AspNetCore.Identity in ein eigenes Projekt namens DL.SO.Services.Security eingefügt. 

Sicherheitseinstellungen in appsettings.json

Ich definiere Konfigurationen, genannt "AppIdentitySettings", für Identitätsoptionen, die ich in ASP.NET Core Identity-Framework in meinem Web-/Startup-Projekt einrichten möchte.

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

Konfigurationsklassen

Dann müssen Sie Konfigurationsklassen definieren, die nur POCOs sind, um Ihre Konfigurationsstruktur in appsettings.json darzustellen. Der Name der Konfigurationsklasse muss nicht mit dem Abschnittsnamen übereinstimmen, den Sie in appsettings.json definieren, sondern die Namen der Eigenschaften müssen übereinstimmen. 

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

Erweiterungsmethode

Sie können die Bindung zwischen appsettings.json und diesen Konfigurationsklassen in Startup Ihres Webprojekts konfigurieren. Ich bevorzuge jedoch, Erweiterungsmethoden in einem separaten Projekt zu definieren, damit Sie Plug-and-Play verwenden können.

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

In Hauptstart einstecken

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

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

        ...
    }
}

Core 1.x

Sie müssen Startup anweisen, die appsettings-Dateien zu laden.

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

Vielen Dank @Kirk für den Hinweis!

85
David Liang

Hinzufügen zu David Liangs Antwort auf Core 2.0

appsettings.json-Dateien sind mit der ASPNETCORE_ENVIRONMENT-Variablen verknüpft.

ASPNETCORE_ENVIRONMENT kann auf einen beliebigen Wert gesetzt werden, das Framework unterstützt jedoch drei Werte: Development, Staging und Production. Wenn ASPNETCORE_ENVIRONMENT nicht festgelegt ist, wird standardmäßig Production verwendet.

Für diese drei Werte werden diese appsettings.ASPNETCORE_ENVIRONMENT.json -Dateien standardmäßig unterstützt - appsettings.Staging.json, appsettings.Development.json und appsettings.Production.json

Die drei oben genannten Anwendungseinstellungs-Json-Dateien können zum Konfigurieren mehrerer Umgebungen verwendet werden.

Beispiel - appsettings.Staging.json 

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

Verwenden SieConfiguration["config_var"], um einen Konfigurationswert abzurufen.

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

Erstellen Sie einfach eine AnyName.cs-Datei und fügen Sie den folgenden Code ein.

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

Muss den Dateinamen von YouAppSettingFile.json durch Ihren Dateinamen ersetzen.
Ihre .json-Datei sollte wie folgt aussehen.

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

Jetzt kannst du es benutzen.
Vergessen Sie nicht, Referenz hinzufügen in Ihrer Klasse, wo Sie sie verwenden möchten.

using Custom;

Code, um den Wert abzurufen.

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

Ich denke, der einfachste Weg ist von DI. Ein Beispiel für den Zugang zum Controller.

// 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

Im Konstruktor der Startup-Klasse können Sie mit dem eingefügten IConfiguration-Objekt auf appsettings.json und viele andere Einstellungen zugreifen:

Startup.cs-Konstruktor

    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;

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

    }

public IConfiguration Configuration { get; }

Inhalt von 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

In meinem Fall war es einfach, die Bind () -Methode für das Konfigurationsobjekt zu verwenden. Fügen Sie dann das Objekt als Singleton in der DI hinzu.

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

Das Instruction-Objekt kann so komplex sein, wie Sie möchten.

{  
 "InstructionSettings": {
    "Header": "uat_TEST",
    "SVSCode": "FICA",
    "CallBackUrl": "https://UATEnviro.companyName.co.za/suite/webapi/receiveCallback",
    "Username": "s_integrat",
    "Password": "[email protected]",
    "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