How to do recursive descent of json using json.net?

Also needed to do something of the sorts. Would like to propose my solution. It has the advantage of:

• not being recursive
• no callbacks
• not assuming any internal structure (arrays)

• decouples tree traversal from the action needed to be executed

  IEnumerable<JToken> AllTokens(JObject obj) {
      var toSearch = new Stack<JToken>(obj.Children());
      while (toSearch.Count > 0) {
          var inspected = toSearch.Pop();
          yield return inspected;
          foreach (var child in inspected) {
              toSearch.Push(child);
          }
      }
  }
  

  Then you can use linq to filter and perform action:

  var tokens = AllTokens(jsonObj);
  var titles = tokens.Where(t => t.Type == JTokenType.Property && ((JProperty)t).Name == "Title");
  

You could also do it with JSONPath: node.SelectTokens("$..*");

Used like this:

var jObjectsWithTitle = node
    .SelectTokens("$..*")
    .OfType<JObject>()
    .Where(x => x.Property("Title") != null);

Or just:

var jObjectsWithTitle = node.SelectTokens("$..[?(@.Title)]");

I thought I'd include my minor tweaks to @BrianRogers WalkNode method, made it slightly more versatile:

private static void WalkNode(JToken node,
                                Action<JObject> objectAction = null,
                                Action<JProperty> propertyAction = null)
{
    if (node.Type == JTokenType.Object)
    {
        if (objectAction != null) objectAction((JObject) node);

        foreach (JProperty child in node.Children<JProperty>())
        {
            if (propertyAction != null) propertyAction(child);
            WalkNode(child.Value, objectAction, propertyAction);
        }
    }
    else if (node.Type == JTokenType.Array)
    {
        foreach (JToken child in node.Children())
        {
            WalkNode(child, objectAction, propertyAction);
        }
    }
}

Then OP could do something like:

WalkNode(json, null, prop =>
{
     if (prop.Name == "Title" && prop.Value.Type == JTokenType.String)
     {
         string title = prop.Value<string>();
         Console.WriteLine(title);
     }
});

The code below should be pretty close to what you are looking for. I made the assumption that there is an outer array, and that arrays can appear anywhere in the hierarchy. (If this is not true, you can simplify the WalkNode method code a bit, but it should work either way.)

using System;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace JsonRecursiveDescent
{
    class Program
    {
        static void Main(string[] args)
        {
            string json =
            @"[
                {
                    ""X"":
                    {
                        ""Title"":""foo"",
                        ""xxxx"":""xxxx""
                    }
                },
                {
                    ""Y"":
                    {
                        ""ZZ"":
                        {
                            ""Title"":""bar"",
                            ""xxxx"":""xxxx""
                        }
                    }
                }
            ]";

            JToken node = JToken.Parse(json);

            WalkNode(node, n =>
            {
                JToken token = n["Title"];
                if (token != null && token.Type == JTokenType.String)
                {
                    string title = token.Value<string>();
                    Console.WriteLine(title);
                }
            });
        }

        static void WalkNode(JToken node, Action<JObject> action)
        {
            if (node.Type == JTokenType.Object)
            {
                action((JObject)node);

                foreach (JProperty child in node.Children<JProperty>())
                {
                    WalkNode(child.Value, action);
                }
            }
            else if (node.Type == JTokenType.Array)
            {
                foreach (JToken child in node.Children())
                {
                    WalkNode(child, action);
                }
            }
        }

    }
}