ASP.NET Core IConfiguration का उपयोग करके Json Array प्राप्त करें

Question

Appsettings.json में

{
      "MyArray": [
          "str1",
          "str2",
          "str3"
      ]
}

---

Startup.cs में

public void ConfigureServices(IServiceCollection services)
{
     services.AddSingleton<IConfiguration>(Configuration);
}

---

होमकंट्रोलर में

public class HomeController : Controller
{
    private readonly IConfiguration _config;
    public HomeController(IConfiguration config)
    {
        this._config = config;
    }

    public IActionResult Index()
    {
        return Json(_config.GetSection("MyArray"));
    }
}

---

ऊपर मेरे कोड हैं, मुझे शून्य मिला है सरणी कैसे प्राप्त करें?

Answer 1

यदि आप पहले आइटम का मूल्य चुनना चाहते हैं तो आपको इस तरह करना चाहिए-

var item0 = _config.GetSection("MyArray:0");

यदि आप संपूर्ण सरणी का मान चुनना चाहते हैं तो आपको इस तरह करना चाहिए-

IConfigurationSection myArraySection = _config.GetSection("MyArray");
var itemArray = myArraySection.AsEnumerable();

आदर्श रूप से, आपको आधिकारिक प्रलेखन द्वारा सुझाए गए विकल्प पैटर्न का उपयोग करने पर विचार करना चाहिए । इससे आपको अधिक लाभ मिलेगा।

Comments

यदि आपके पास वस्तुओं की एक सरणी है "Clients": [ {..}, {..} ], तो आपको आह्वान करना चाहिए Configuration.GetSection("Clients").GetChildren()।

— हॉलो

यदि आपके पास शाब्दिक अर्थ है "Clients": [ "", "", "" ], तो आपको आमंत्रित करना चाहिए .GetSection("Clients").GetChildren().ToArray().Select(c => c.Value).ToArray()।

— हॉलो

यह उत्तर वास्तव में 4 वस्तुओं का उत्पादन करेगा, पहला खंड जो स्वयं एक खाली मूल्य के साथ है। यह गलत है।

— गियोवन्नी बस्सी

मैं इसे सफलतापूर्वक इस तरह लागू करता हूं:var clients = Configuration.GetSection("Clients").GetChildren() .Select(clientConfig => new Client { ClientId = clientConfig["ClientId"], ClientName = clientConfig["ClientName"], ... }) .ToArray();

— हॉलो

इन विकल्पों में से कोई भी मेरे लिए काम नहीं करता है क्योंकि ऑब्जेक्ट "ग्राहकों" के बिंदु पर शून्य से वापस आ रहा है। मुझे विश्वास है कि जोंस अच्छी तरह से बना हुआ है क्योंकि यह स्ट्रिंग में डाली गई ऑफसेट के साथ काम करता है ["आइटम: 0: childItem"] प्रारूप में "आइटम": [{...}, {...}]

— स्पष्टता

Answer 2

आप निम्नलिखित दो NuGet पैकेज स्थापित कर सकते हैं:

Microsoft.Extensions.Configuration    
Microsoft.Extensions.Configuration.Binder

और फिर आपको निम्नलिखित एक्सटेंशन विधि का उपयोग करने की संभावना होगी:

var myArray = _config.GetSection("MyArray").Get<string[]>();

Comments

यह अन्य उत्तरों की तुलना में बहुत अधिक सीधा है।

— जावेद

यह अब तक का सबसे अच्छा जवाब है।

— गियोवन्नी बस्सी

मेरे मामले में, Aspnet core 2.1 वेब ऐप, इन दो नगेट पैकेजों को शामिल करता है। तो इसका सिर्फ एक लाइन परिवर्तन था। धन्यवाद

— शिबू Thannikkunnath

सबसे सरल एक!

— पाब्लो

यह वस्तुओं की सरणी के साथ भी काम करता है, जैसे _config.GetSection("AppUser").Get<AppUser[]>();

— जियोगोस बेट्स

Answer 3

अपने appsettings.json में एक स्तर जोड़ें:

{
  "MySettings": {
    "MyArray": [
      "str1",
      "str2",
      "str3"
    ]
  }
}

अपने अनुभाग का प्रतिनिधित्व करने वाला एक वर्ग बनाएँ:

public class MySettings
{
     public List<string> MyArray {get; set;}
}

अपने एप्लिकेशन स्टार्टअप वर्ग में, अपने मॉडल को DI सेवा में इंजेक्ट करें:

services.Configure<MySettings>(options => Configuration.GetSection("MySettings").Bind(options));

और आपके कंट्रोलर में, DI सेवा से अपना कॉन्फ़िगरेशन डेटा प्राप्त करें:

public class HomeController : Controller
{
    private readonly List<string> _myArray;

    public HomeController(IOptions<MySettings> mySettings)
    {
        _myArray = mySettings.Value.MyArray;
    }

    public IActionResult Index()
    {
        return Json(_myArray);
    }
}

आप अपने पूरे कॉन्फ़िगरेशन मॉडल को अपने कंट्रोलर में किसी प्रॉपर्टी में स्टोर कर सकते हैं, यदि आपको सभी डेटा की आवश्यकता है:

public class HomeController : Controller
{
    private readonly MySettings _mySettings;

    public HomeController(IOptions<MySettings> mySettings)
    {
        _mySettings = mySettings.Value;
    }

    public IActionResult Index()
    {
        return Json(_mySettings.MyArray);
    }
}

ASP.NET कोर की निर्भरता इंजेक्शन सेवा एक आकर्षण की तरह काम करती है :)

Comments

तो आप MySettingsस्टार्टअप में कैसे उपयोग करते हैं ?

— T.Coutlakis

मुझे एक त्रुटि मिलती है कि इसे "MySettings" और "MyArray" के बीच अल्पविराम की आवश्यकता है।

— मार्कस

Answer 4

यदि आपके पास इस तरह की जटिल JSON ऑब्जेक्ट्स की सरणी है:

{
  "MySettings": {
    "MyValues": [
      { "Key": "Key1", "Value":  "Value1" },
      { "Key": "Key2", "Value":  "Value2" }
    ]
  }
}

आप इस तरह से सेटिंग्स पुनः प्राप्त कर सकते हैं:

var valuesSection = configuration.GetSection("MySettings:MyValues");
foreach (IConfigurationSection section in valuesSection.GetChildren())
{
    var key = section.GetValue<string>("Key");
    var value = section.GetValue<string>("Value");
}

Answer 5

यह मेरे लिए मेरे विन्यास से तार की एक सरणी वापस करने के लिए काम किया:

var allowedMethods = Configuration.GetSection("AppSettings:CORS-Settings:Allow-Methods")
    .Get<string[]>();

मेरा कॉन्फ़िगरेशन अनुभाग इस तरह दिखता है:

"AppSettings": {
    "CORS-Settings": {
        "Allow-Origins": [ "http://localhost:8000" ],
        "Allow-Methods": [ "OPTIONS","GET","HEAD","POST","PUT","DELETE" ]
    }
}

Answer 6

कॉन्फ़िगरेशन से जटिल JSON ऑब्जेक्ट्स की एक सरणी वापस करने के मामले में, मैंने tuples के बजाय अनाम प्रकारों और गतिशील का उपयोग करने के लिए @ djangojazz के उत्तर को अनुकूलित किया है ।

की सेटिंग अनुभाग दिया गया:

"TestUsers": [
{
  "UserName": "TestUser",
  "Email": "[e-mail]",
  "Password": "P@ssw0rd!"
},
{
  "UserName": "TestUser2",
  "Email": "[e-mail]",
  "Password": "P@ssw0rd!"
}],

आप इस तरह से ऑब्जेक्ट ऐरे को वापस कर सकते हैं:

public dynamic GetTestUsers()
{
    var testUsers = Configuration.GetSection("TestUsers")
                    .GetChildren()
                    .ToList()
                    .Select(x => new {
                        UserName = x.GetValue<string>("UserName"),
                        Email = x.GetValue<string>("Email"),
                        Password = x.GetValue<string>("Password")
                    });

    return new { Data = testUsers };
}

Comments

यह कमाल है

— व्लादिमीर Demirev

Answer 7

एक पुराने प्रश्न का प्रकार, लेकिन मैं C # 7 मानकों के साथ .NET कोर 2.1 के लिए अद्यतन उत्तर दे सकता हूं। कहो कि मेरे पास केवल ऐपेटिंग्स में एक सूची है। विकास। इस तरह के रूप में:

"TestUsers": [
  {
    "UserName": "TestUser",
    "Email": "[e-mail]",
    "Password": "P@ssw0rd!"
  },
  {
    "UserName": "TestUser2",
    "Email": "[e-mail]",
    "Password": "P@ssw0rd!"
  }
]

मैं उन्हें कहीं भी निकाल सकता हूँ कि Microsoft.Extensions.Configuration.IConfiguration को लागू किया गया है और इस तरह से तार दिया गया है:

var testUsers = Configuration.GetSection("TestUsers")
   .GetChildren()
   .ToList()
    //Named tuple returns, new in C# 7
   .Select(x => 
         (
          x.GetValue<string>("UserName"), 
          x.GetValue<string>("Email"), 
          x.GetValue<string>("Password")
          )
    )
    .ToList<(string UserName, string Email, string Password)>();

अब मेरे पास एक अच्छी टाइप की गई वस्तु की एक सूची है जो अच्छी तरह से टाइप की गई है। अगर मैं testUsers.irst जाता हूं (), तो Visual Studio को अब 'UserName', 'Email', और 'Password' के विकल्प दिखाने चाहिए।

Answer 8

ASP.NET Core 2.2 में और बाद में हम आपके आवेदन की तरह कहीं भी हमारे आवेदन में IConfiguration को इंजेक्ट कर सकते हैं, आप HomeController में IConfiguration को इंजेक्ट कर सकते हैं और इस तरह का उपयोग करके सरणी प्राप्त कर सकते हैं।

string[] array = _config.GetSection("MyArray").Get<string[]>();

Answer 9

आप कॉन्फ़िगरेशन में एक नए स्तर की वृद्धि के बिना सरणी को सीधे प्राप्त कर सकते हैं:

public void ConfigureServices(IServiceCollection services) {
    services.Configure<List<String>>(Configuration.GetSection("MyArray"));
    //...
}

Answer 10

संक्षिप्त रूप:

var myArray= configuration.GetSection("MyArray")
                        .AsEnumerable()
                        .Where(p => p.Value != null)
                        .Select(p => p.Value)
                        .ToArray();

यह स्ट्रिंग की एक सरणी देता है:

{ "Str1", "str2", "str3"}

Comments

मेरे लिए काम किया। धन्यवाद। Microsoft.Extensions.Configuration.Binder का उपयोग करना भी बहुत काम करता है, हालाँकि मैं एक और Nuget पैकेज को संदर्भित करने से दूर रहना चाहूँगा यदि कोड की एक भी लाइन काम कर सकती है।

— Sau001

Answer 11

इसने मेरे लिए काम किया; कुछ json फ़ाइल बनाएँ:

{
    "keyGroups": [
        {
            "Name": "group1",
            "keys": [
                "user3",
                "user4"
            ]
        },
        {
            "Name": "feature2And3",
            "keys": [
                "user3",
                "user4"
            ]
        },
        {
            "Name": "feature5Group",
            "keys": [
                "user5"
            ]
        }
    ]
}

फिर, कुछ वर्ग को परिभाषित करें जो नक्शे:

public class KeyGroup
{
    public string name { get; set; }
    public List<String> keys { get; set; }
}

नगेट पैकेज:

Microsoft.Extentions.Configuration.Binder 3.1.3
Microsoft.Extentions.Configuration 3.1.3
Microsoft.Extentions.Configuration.json 3.1.3

फिर, इसे लोड करें:

using Microsoft.Extensions.Configuration;
using System.Linq;
using System.Collections.Generic;

ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();

configurationBuilder.AddJsonFile("keygroup.json", optional: true, reloadOnChange: true);

IConfigurationRoot config = configurationBuilder.Build();

var sectionKeyGroups = 
config.GetSection("keyGroups");
List<KeyGroup> keyGroups = 
sectionKeyGroups.Get<List<KeyGroup>>();

Dictionary<String, KeyGroup> dict = 
            keyGroups = keyGroups.ToDictionary(kg => kg.name, kg => kg);