Question

And there could be many levels, who knows how deep it could go! Also let’s say for this specific question that the String for another Dictionary will be “Dictionary” and a value that I want to access/modify will be “Data”.

Answer 1

Will I need a recursive function to iterate through a Dictionary<String, Object> of Dictionary<String, Object>s?

No. Any recursive algorithm can be rewritten to use an explicit stack rather than the call stack.

Is it easier to use recursion to do so?

Perhaps. However, if the structure is very deeply nested (or contains cycles) you can run the risk of a stack overflow exception.

The non-recursive implementation is not particularly hard to implement. It would require you to maintain a list (a stack or queue, depending on what order you want to visit children in) that keeps track of the sub-dictionaries yet to be visited.

A prototypical (non-recursive) implementation would look something like:

public IEnumerable<string> GetAllKeys( Dictionary<string,object> dictionary )
{
    var stackDictionariesToVisit = new Stack<Dictionary<string,object>>();

    stackDictionariesToVisit.Push( dictionary );

    // keep visiting iterating until the stack of dictionaries to visit is empty
    while( stackDictionariesToVisit.Count > 0 )
    {
        var nextDictionary = stackDictionariesToVisit.Pop();
        foreach( var keyValuePair in nextDictionary )
        {
            if( keyValuePair.Value is Dictionary<string,object> )
            {
                stackDictionariesToVisit.Push( 
                     keyValuePair.Value as Dictionary<string,object> );
            }
            else
            {
                yield return keyValuePair.Key;
            }
        }
    }
}

The implementation above does no error checking and it doesn’t check for cycles, but it replaces recursion with an explicit stack.

The choice of whether to use recursion (or not) for visiting a hierarchical data structure should depend on an understanding of the kind of data being stored rather than which approach is easier. If you have a deeply nested structure, you are better off NOT using recursion since you can’t control how much stack space you’ll have available. On the other hand, if you are confident that the data will never nest more than a few level, a recursive implementation may be (slightly) easier to understand and maintain.