Comment charger appsetting.json section dans le Dictionnaire .NET de Base?

Je suis familier w/chargement d'un appsettings.json section dans un objet fortement typé .NET de Base démarrage.cs. Par exemple:

public class CustomSection 
{
   public int A {get;set;}
   public int B {get;set;}
}

//In Startup.cs
services.Configure<CustomSection>(Configuration.GetSection("CustomSection"));

//Inject an IOptions instance
public HomeController(IOptions<CustomSection> options) 
{
    var settings = options.Value;
}

J'ai un appsettings.json section qui de paires clé/valeur varie en nombre et nom au fil du temps. Par conséquent, il n'est pas pratique pour coder en dur les noms de propriété dans une classe, puisque de nouvelles paires clé/valeur nécessiterait une modification du code dans la classe. Un petit échantillon de quelques paires clé/valeur:

"MobileConfigInfo": {
    "appointment-confirmed": "We've booked your appointment. See you soon!",
    "appointments-book": "New Appointment",
    "appointments-null": "We could not locate any upcoming appointments for you.",
    "availability-null": "Sorry, there are no available times on this date. Please try another."
}

Est-il un moyen de charger ces données dans un MobileConfigInfo Dictionnaire de l'objet, puis utilisez l'IOptions modèle à injecter MobileConfigInfo dans un contrôleur?

Hmmm n'est pas vraiment au sujet de cette question ASP.NET de Base et pas .NET de Base? Peu un titre trompeur.

OriginalL'auteur ChrisP | 2017-03-16

  1. 17

    Vous pouvez utiliser Configuration.Bind(settings); dans startup.cs classe

    Et vos paramètres de classe sera comme 

    public class AppSettings
{
    public Dictionary<string, string> MobileConfigInfo
    {
        get;
        set;
    }
}

    Espère que cela aide!

    Je suis en train d'essayer de comprendre l'exemple que vous avez fourni, mais il est très déroutant. Qu'est-ce que settings?
    est une instance de AppSettings classe. Le Bind méthode de mapper les valeurs de votre config.json à votre settings instance. Après cela, vous pouvez utiliser .AddSingleton ou quelque chose comme ça pour l'injecter dans d'autres classes

    OriginalL'auteur Hung Cao

  2. 14

    Aller avec ce format de structure:

    "MobileConfigInfo": {
    "Values": {
       "appointment-confirmed": "We've booked your appointment. See you soon!",
       "appointments-book": "New Appointment",
       "appointments-null": "We could not locate any upcoming appointments for you.",
       "availability-null": "Sorry, there are no available times on this date. Please try another."
 }
}

    Faire de votre réglage de classe ressembler à ceci:

    public class CustomSection 
{
   public Dictionary<string, string> Values {get;set;}
}

    ensuite ce faire

    services.Configure<CustomSection>((settings) =>
{
     Configuration.GetSection("MobileConfigInfo").Bind(settings);
});
    Cela a fonctionné pour moi. Fonctionne également si le dictionnaire est au plus profond de la section de configuration, avec l'appel de liaison.

    OriginalL'auteur code5

  3. 11

    Pour d'autres qui veulent convertir un Dictionnaire,

    exemple de section à l'intérieur de appsettings.json

    "MailSettings": {
    "Server": "http://mail.mydomain.com"        
    "Port": "25",
    "From": "[email protected]"
 }

    Code suivant doit être placé dans le fichier de Démarrage > ConfigureServices méthode:

    public static Dictionary<string, object> MailSettings { get; private set; }

public void ConfigureServices(IServiceCollection services)
{
    //ConfigureServices code......

    MailSettings = 
        Configuration.GetSection("MailSettings").GetChildren()
        .Select(item => new KeyValuePair<string, string>(item.Key, item.Value))
        .ToDictionary(x => x.Key, x => x.Value);
}

    Vous pouvez maintenant accéder au dictionnaire à partir de n'importe où, comme:

    string mailServer = Startup.MailSettings["Server"];

    Un inconvénient est que toutes les valeurs seront récupérés comme des chaînes de caractères, si vous essayez de tout autre type de la valeur sera nulle.

    Vous n'avez pas besoin de la .Select(item => new KeyValuePair<string, string>(item.Key, item.Value)) partie. Vous pouvez les appeler GetChildren().ToDictionary(x => x.Key, x => x.Value).

    OriginalL'auteur Amro

  4. 3

    Je crois que vous pouvez utiliser le code suivant:

    var config =  Configuration.GetSection("MobileConfigInfo").Get<Dictionary<string, string>>();

    OriginalL'auteur macpak

  5. 2

    Simple (peut-être microservice) d'applications que vous pouvez ajouter simplement comme un singleton Dictionary<string, string> et puis à l'injecter partout où vous en avez besoin:

    var mobileConfig = Configuration.GetSection("MobileConfigInfo")
                    .GetChildren().ToDictionary(x => x.Key, x => x.Value);

services.AddSingleton(mobileConfig);

    Et l'utilisation:

    public class MyDependantClass
{
    private readonly Dictionary<string, string> _mobileConfig;

    public MyDependantClass(Dictionary<string, string> mobileConfig)
    {
        _mobileConfig = mobileConfig;
    }

    //Use your mobile config here
}

    OriginalL'auteur ste-fu

  6. 1

    Comme un exemple plus complexe de liaison dans ASP.Net de Base 2.1; j'ai trouvé à l'aide de la ConfigurationBuilder .Get<T>() méthode beaucoup plus facile de travailler avec, comme par la documention.

    ASP.NET de Base 1.1 et supérieur peuvent utiliser Get, qui travaille avec l'ensemble des sections. Obtenir peut être plus pratique que d'utiliser Bind.

    Que j'ai lié la configuration dans mon Startup méthode.

    private Config Config { get; }

public Startup(IConfiguration Configuration)
{
    Config = Configuration.Get<Config>();
}

    Cette lie la appsettings fichier:

    {
    "ConnectionStrings": {
        "Accounts": "Server=localhost;Database=Accounts;Trusted_Connection=True;",
        "test": "Server=localhost;Database=test;Trusted_Connection=True;",
        "Client": "Server=localhost;Database={DYNAMICALLY_BOUND_CONTEXT};Trusted_Connection=True;",
        "Support": "Server=localhost;Database=Support;Trusted_Connection=True;"
    },
    "Logging": {
        "IncludeScopes": false,
        "LogLevel": {
            "Default": "Debug",
            "System": "Information",
            "Microsoft": "Information"
        }
    },
    "Plugins": {
        "SMS": {
            "RouteMobile": {
                "Scheme": "https",
                "Host": "remote.host",
                "Port": 84567,
                "Path": "/bulksms",
                "Username": "username",
                "Password": "password",
                "Source": "CompanyName",
                "DeliveryReporting": true,
                "MessageType": "Unicode"
            }
        },
        "SMTP": {
            "GenericSmtp": {
                "Scheme": "https",
                "Host": "mail.host",
                "Port": 25,
                "EnableSsl": true,
                "Username": "[email protected]",
                "Password": "password",
                "DefaultSender": "[email protected]"
            }
        }
    }
}

    Dans cette configuration de la structure:

    [DataContract]
public class Config
{
[DataMember]
public Dictionary<string, string> ConnectionStrings { get; set; }
[DataMember]
public PluginCollection Plugins { get; set; }
}
[DataContract]
public class PluginCollection
{
[DataMember]
public Dictionary<string, SmsConfiguration> Sms { get; set; }
[DataMember]
public Dictionary<string, EmailConfiguration> Smtp { get; set; }
}
[DataContract]
public class SmsConfiguration
{
[DataMember]
public string Scheme { get; set; }
[DataMember]
public string Host { get; set; }
[DataMember]
public int Port { get; set; }
[DataMember]
public string Path { get; set; }
[DataMember]
public string Username { get; set; }
[DataMember]
public string Password { get; set; }
[DataMember]
public string Source { get; set; }
[DataMember]
public bool DeliveryReporting { get; set; }
[DataMember]
public string Encoding { get; set; }
}
[DataContract]
public class EmailConfiguration
{
[DataMember]
public string Scheme { get; set; }
[DataMember]
public string Host { get; set; }
[DataMember]
public int Port { get; set; }
[DataMember]
public string Path { get; set; }
[DataMember]
public string Username { get; set; }
[DataMember]
public string Password { get; set; }
[DataMember]
public string DefaultSender { get; set; }
[DataMember]
public bool EnableSsl { get; set; }
}

    OriginalL'auteur derpasaurus

  7. 0

    - Je utiliser de la manière ci-dessous:

    appsettings.json:

      "services": {
"user-service": "http://user-service:5000/",
"app-service": "http://app-service:5000/"
}

    de démarrage.cs:

      services.Configure<Dictionary<string, string>>(Configuration.GetSection("services"));

    Utilisation：

    private readonly Dictionary<string, string> _services;
public YourConstructor(IOptions<Dictionary<string, string>> servicesAccessor)
{
_services = servicesAccessor.Value;
}

    OriginalL'auteur ErikXu

  8. 0

    De loin la méthode la plus simple consisterait à définir votre configuration de classe hérite de la type de Dictionnaire que vous voulez soutenir.

    public class MobileConfigInfo:Dictionary<string, string>{
}

    Alors votre de démarrage de l'injection de dépendance et de soutien serait exactement la même que pour tout autre type de configuration.

    OriginalL'auteur Jeremy Lakeman