मैं नेस्टेड शब्दकोश के साथ इस डेटास्ट्रक्चर को बनाने की कोशिश कर रहा हूं:

["A",["A",123]],
["B",["B",123]],
["C",["C",123]],

और फिर डेटा संरचना पर लूप करें और मानों का प्रिंट आउट लें।

पहली समस्या यह है कि सभी नेस्टेड शब्दकोश समान {"C",123} हैं। मुझे लगता है कि ऐसा इसलिए है क्योंकि यह वही वस्तु है, लेकिन मुझे नहीं पता कि इसे कैसे दूर किया जाए। क्या मैं गतिशील रूप से लूप में नई वस्तुएं बना सकता हूं?

मुझे जिस दूसरी समस्या का सामना करना पड़ता है वह लूप में है जहां मैं मूल्यों को मुद्रित करने का प्रयास करता हूं। कंपाइलर का कहना है कि यह डिक्शनरी को डिक्शनरी में नहीं बदल सकता है।

using System;
using System.Collections.Generic;

namespace ConsoleApp1
{
    class Program
    {
        public static void Main()
        {
            List<string> liste = new() { "A", "B", "C" };
 
            Dictionary<string, Dictionary<string, int>> DictOfDicts = new();
            Dictionary<string, int> DictOfData = new();

            foreach (string i in liste)
            {
                DictOfData.Clear();
                DictOfData.Add(i, 123);
                DictOfDicts.Add(i, DictOfData);
            }
            foreach (Dictionary<string, int> i in DictOfDicts)
            {
                Console.WriteLine("Some result");
            }
        }
    }
}
c#
0
Kresten 6 जून 2021, 12:52

4 जवाब

सबसे बढ़िया उत्तर
var liste = new List<string>() { "A", "B", "C" };
var DictOfDicts = new Dictionary<string, Dictionary<string, int>>();

foreach (var i in liste)
{
  // Create here a new DictOfData to add it to DicOfCicts.
  var DictOfData = new Dictionary<string, int>();
  DictOfData.Add(i, 123);
  DictOfDicts.Add(i, DictOfData);
}

DicOfDicts की संरचना है,

["A",["A",123]],
["B",["B",123]],
["C",["C",123]],
1
Themelis 6 जून 2021, 16:27

आपने DictOfData को foreach लूप के बाहर घोषित किया है। फिर, लूप के अंदर सभी ऑपरेशन एक ही ऑब्जेक्ट पर किए जाते हैं। तो, आप प्रत्येक लूप पुनरावृत्ति पर एक ही शब्दकोश ऑब्जेक्ट को बार-बार साफ़ और भर रहे हैं।

बस आपको DictOfData की घोषणा को लूप के अंदर ले जाएं, और आपका जाना अच्छा रहेगा।


बोनस:

आपके द्वारा प्रश्नों में प्रदर्शित किया गया पूरा ऑपरेशन बस इसके साथ किया जा सकता है:

liste.ToDictionary(x => x, x => new Dictionary<string, int>() { { x, 123 } })
2
Rodrigo Rodrigues 6 जून 2021, 14:10

मैंने उत्तर के लिए थोड़ा पुराना सी # भाषा विनिर्देश का उपयोग किया है, और आपके लिए समझने के लिए प्रकार की घोषणाओं को और अधिक स्पष्ट कर दिया है।

List<string> list = new List<string>() { "A", "B", "C" };

Dictionary<string, Dictionary<string, int>> parent = new Dictionary<string, Dictionary<string, int>>();


foreach (string i in list)
{
    Dictionary<string, int> child = new Dictionary<string, int>();
    child.Add(i, 123);
    parent.Add(i, child);
}
foreach (KeyValuePair<string, Dictionary<string, int>> parentPair in parent)
{
    Dictionary<string, int> childDictionary = parentPair.Value;
    foreach (var childPair in childDictionary)
    {
        Console.WriteLine(childPair.Value);
    }
}
0
Jonas Hendrickx 6 जून 2021, 13:04

अपने कोड को ठीक करने के लिए यह एक बहुत ही आसान अभ्यास है। बस DictOfData.Clear(); को DictOfData की घोषणा से बदलें। दूसरे शब्दों में, लाइन Dictionary<string, int> DictOfData = new(); को लूप में ले जाएं। इस तरह आपके पास पुराने शब्दकोश का पुन: उपयोग करने के बजाय नेस्टेड शब्दकोश का एक नया उदाहरण है।

इस कोड को आजमाएं:

List<string> liste = new() { "A", "B", "C" };

Dictionary<string, Dictionary<string, int>> DictOfDicts = new();

foreach (string i in liste)
{
    Dictionary<string, int> DictOfData = new();
    DictOfData.Add(i, 123);
    DictOfDicts.Add(i, DictOfData);
}
foreach (KeyValuePair<string, Dictionary<string, int>> i in DictOfDicts)
{
    Console.WriteLine($"[{i.Key},{String.Join(",", i.Value.Select(x => $"[{x.Key},{x.Value}]"))}]");
}
0
Enigmativity 6 जून 2021, 13:52