Populate hierarchy in Dictionary-CodePudding

I need to build a hierarchy and I am using a dictionary. I read strings randomly when I am trying to build this and they have this format:

address.city.streetname.housenumber

address.areacode

address.city.streetname.coAddress

I have a problem figuring out how to populate the entire hierarchy This is what I have done:

public class JsonElement
{
    public string parent { get; set; }
    public string name { get; set; }
    public List<JsonElement> childrenJsonElements { get; set; }
}

var dictionaryHierarchy = new Dictionary<string, JsonElement>();

List<string> stringList = new List<string>()
{ "address.city.streetname.housenumber",
   "address.areacode",
   "address.city.streetname.coAddress"};


foreach(string element in stringList)
{
   string[] tagsStringArray = element.Split('.');

   if (!dictionaryHierarchy.ContainsKey(tagsStringArray[0]))
   {
       dictionaryHierarchy.Add(tagsStringArray[0], new JsonElement());
   }

    dictionaryHierarchy = AddElementsToHierarchy();
 }


private static Dictionary<string, JsonElement> AddElementsToHierarchy(Dictionary<string, 
JsonElement> dictionaryHierarchy, string element)
{
    JsonElement jsonElement = new JsonElement();
    string[] tagsStringArray = element.Split('.');

   if (tagsStringArray.Length < 2)
   {
     return dictionaryJsonHierarchy;
   }

   jsonElement = dictionaryHierarchy[tagsStringArray[0]];
   int ix = 1;

   while (ix < tagsStringArray.Length)
   {
      if (jsonElement.name != tagsStringArray[ix])
      {
          jsonElement.parent = tagsStringArray[ix-1];
          jsonElement.name = tagsStringArray[ix];
      }
    else
    {
       ; // This part is for adding children
    }
    
    ix  ;
   }

   return dictionaryHierarchy;
 }

CodePudding user response：

You have a tree structure made up of JsonElement nodes. This structure is the only data structure you need. Let's redefine JsonElement:

public class JsonElement
{
    public string Parent { get; set; }
    public string Name { get; set; }
    public List<JsonElement> Children { get; } = new List<JsonElement>();
}

We made the properties PascalCase. This is the usual naming convetion. The Children are a read-only property with an initializer which instantiates the list.

As suggested, we add some more examples:

var input = new[] {
    "address.city.streetname.housenumber",
    "address.areacode",
    "address.city.streetname.coAddress",
    "person.name.firstname",
    "person.name.lastname"
};

Now, we have two different elements at the start of the hierarchy. To enable this scenario, we add a neutral root element with a null name.

var root = new JsonElement();
foreach (string s in input) {
    AddElements(root, s.Split('.'));
}

Now, let's create the hierarchy.

Adding elements consists of walking down the tree structure by following the tags (names). If one is missing, we add it.

private static void AddElements(JsonElement node, string[] elements)
{
    foreach (string element in elements) {
        var child = node.Children.Find(child => child.Name == element);
        if (child == null) {
            child = new JsonElement {
                Parent = node.Name,
                Name = element
            };
            node.Children.Add(child);
        }
        node = child; // Walk down the tree
    }
}

We can test the result with this recursive method:

private static void PrintChildren(JsonElement node, int level = 0)
{
    string indent = new String(' ', 4 * level);
    foreach (var child in node.Children) {
        Console.WriteLine($"{indent}{child.Name},  Parent = {child.Parent}");
        PrintChildren(child, level   1);
    }
}

Called with PrintChildren(root); it prints:

address,  Parent =
    city,  Parent = address
        streetname,  Parent = city
            housenumber,  Parent = streetname
            coAddress,  Parent = streetname
    areacode,  Parent = address
person,  Parent =
    name,  Parent = person
        firstname,  Parent = name
        lastname ,  Parent = name