嵌套字典的递归

Question

I have a dictionary with multiples values. My dictionary is as:

public class checkitems: Dictionary<int, checkitems>{
  // ....
}

I am looping over each level like this.

foreach(KeyValuePair<int, checkitems> first in items){
   foreach(KeyValuePair<int, checkitems> second in first.values){
       foreach(KeyValuePair<int, checkitems> third in second.values){
          List<int> list1 = new List<int>(); 
          if(third.Value.Age > 20){ 
              list.Add(x.key)
           }
        }
        foreach(var deleteKeys in list1){
        second.Value.Remove(deleteKeys)
        }
    }
}

Currently i am writing foreach for each level and checking to see if it satisfies the condition and then adding it to the list to remove. I wanted to know how would i write it recursively so that i wouldn't have to worry about how much deep the levels go.

Example data format:
    Companies 
         i. Apple
            a. key: Macbookpro   Value: 200
            b (key): IMAC        Value: 334
            c (key): Iphone      Value : 12
                1. (key) IOS8    Value : 13
                2. (key) IOS7    Value : 15
            d (key): Beats       Value: 20

Answer 1

I did my best in understanding what your code is trying to achieve. Hope this helps

using System;
using System.Collections.Generic;

namespace ConsoleApplication2
{
    public static class Program
    {
        public static void RecurseCheckitems(CheckItems items)
        {
            List<Int32> l_deleteKeys = new List<Int32>();

            // Step 1: DFS - Down down down to the deepest level
            foreach (Int32 key in items.Keys)
            {
                RecurseCheckitems(items[key]);
            }

            // Step 2: Extract all KEYS of Childelements having an AGE of at least 20
            foreach (Int32 key in items.Keys)
            {
                l_deleteKeys.AddRange(DoCheckItems(items[key]));
            }

            // Step 3: Remove all extracted keys from the current Objecct
            foreach (Int32 deleteKey in l_deleteKeys)
            {
                items.Remove(deleteKey);
            }
        }

        /// <summary>
        /// Helper-Function to extract the keys of Child-Elements having an age of at least 20
        /// </summary>
        /// <param name="item">Parent-Item to check</param>
        /// <returns>List of KEYS of Child-Elements having an Age of at least 20</returns>
        private static List<Int32> DoCheckItems(CheckItems item)
        {
            List<Int32> l = new List<Int32>();

            foreach (Int32 key in item.Keys)
            {
                if (item[key].Age > 20)
                {
                    l.Add(key);
                }
            }

            return l;
        }
    }

    public sealed class CheckItems : Dictionary<Int32, CheckItems>
    {
        public Int32 Age { get; set; }
    }
}

Answer 2

Given a root instance of checkitems , try this:

Func<checkitems, IEnumerable<Tuple<checkitems, checkitems>>> flatten = null;
flatten = cis =>
    cis
        .Select(x => Tuple.Create(cis, x.Value))
        .Concat(cis.SelectMany(c => flatten(c.Value)));

foreach (var tuple in flatten(root)
    .Where(x => x.Item2.Age > 20)
    .ToArray())
{
    tuple.Item1.Remove(tuple.Item2);
}