JSON.NET: Flattening a JArray to JObjects within Linq Query - linq

Question

This is a follow-up to my earlier post, here:
Querying and Filtering Array of JObjects with Linq
I posted a dotnetfiddle here:
https://dotnetfiddle.net/s75wGu
Apologies, but I couldn't figure out why I'm getting an error on System.Collections.Generic.IEnumerable in dotnetfiddle, but the program works under Linqpad and Visual Studio.
The source JSON looks like this:
{
"Object": {
"NM": "Name1",
"AA": "Val01",
"BB": "Val02",
"CC": "Val03",
"DD": "Val04",
"EE": "Val05",
"FF": "Val06",
"GG": "Val07",
"HH": "Val08",
"Object": [
{
"NM": "Name2",
"AA": "Val01",
"BB": "Val02",
"CC": "Val03",
"DD": "Val04",
"EE": "Val05",
"FF": "Val06",
"GG": "Val07",
"HH": "Val08",
"Object": [
{
"NM": "Name3",
"AA": "Val01",
"BB": "Val02",
"CC": "Val03",
"DD": "Val04",
"EE": "Val05",
"FF": "Val06",
"GG": "Val07",
"HH": "Val08"
},
{
"NM": "Name4",
"AA": "Val01",
"BB": "Val02",
"CC": "Val03",
"DD": "Val04",
"EE": "Val05",
"FF": "Val06",
"GG": "Val07",
"HH": "Val08"
},
{
"NM": "Name5",
"AA": "Val01",
"BB": "Val02",
"CC": "Val03",
"DD": "Val04",
"EE": "Val05",
"FF": "Val06",
"GG": "Val07",
"HH": "Val08"
}
]
}
]
}
}
As you can see, the code is designed to query a JSON document and flatten it to a List<JObject> object.
The if (jo is JObject) clause should be straightforward: If the Linq iteration finds a JObject object, it creates a joWork JObject instance, adds properties to it, and returns the single joWork object. This works fine.
But my problem is working with the if (jo is JArray) clause: Here, I think that Linq expects me to return a single JObject object, but I've got an array of JObjects that I want to return as separate JObjects.
The output produced by my dotnetfiddle code is this:
joWork-Object: {
"_Parent": "",
"NM": "Name1",
"AA": "Val01",
"BB": "Val02",
"CC": "Val03",
"DD": "Val04",
"EE": "Val05",
"FF": "Val06",
"GG": "Val07",
"HH": "Val08"
}
joWork-Array: {
"_Parent": "Name1",
"_Group": 1,
"NM": "Name2",
"AA": "Val01",
"BB": "Val02",
"CC": "Val03",
"DD": "Val04",
"EE": "Val05",
"FF": "Val06",
"GG": "Val07",
"HH": "Val08"
}
joWork:
joWork-Array: {
"_Parent": "Name2",
"_Group": 2,
"NM": "Name5",
"AA": "Val01",
"BB": "Val02",
"CC": "Val03",
"DD": "Val04",
"EE": "Val05",
"FF": "Val06",
"GG": "Val07",
"HH": "Val08"
}
joWork:
joWork:
joWork:
Notice that we have Object Name (NM) Name1, Name2, then Name5 only. What I would like is to have Name1, Name2, Name3, Name4, and Name5--each having a _Parent property that contains to the parent object's NM property.
I realize I'm getting only Name5 because the JArray if statement in my Linq query returns only the last element in the array. I would like to return all elements in the array. The final output should look like this:
joWork-Object: {
"_Parent": "",
"NM": "Name1",
"AA": "Val01",
"BB": "Val02",
"CC": "Val03",
"DD": "Val04",
"EE": "Val05",
"FF": "Val06",
"GG": "Val07",
"HH": "Val08"
}
joWork-Array: {
"_Parent": "Name1",
"_Group": 1,
"NM": "Name2",
"AA": "Val01",
"BB": "Val02",
"CC": "Val03",
"DD": "Val04",
"EE": "Val05",
"FF": "Val06",
"GG": "Val07",
"HH": "Val08"
}
joWork-Array: {
"_Parent": "Name2",
"_Group": 2,
"NM": "Name3",
"AA": "Val01",
"BB": "Val02",
"CC": "Val03",
"DD": "Val04",
"EE": "Val05",
"FF": "Val06",
"GG": "Val07",
"HH": "Val08"
}
joWork-Array: {
"_Parent": "Name2",
"_Group": 2,
"NM": "Name4",
"AA": "Val01",
"BB": "Val02",
"CC": "Val03",
"DD": "Val04",
"EE": "Val05",
"FF": "Val06",
"GG": "Val07",
"HH": "Val08"
}
joWork-Array: {
"_Parent": "Name2",
"_Group": 2,
"NM": "Name5",
"AA": "Val01",
"BB": "Val02",
"CC": "Val03",
"DD": "Val04",
"EE": "Val05",
"FF": "Val06",
"GG": "Val07",
"HH": "Val08"
}

Answer 1

You can use Enumerable.SelectMany() in place of Enumerable.Select() to return multiple objects inside a linq query, flattening out the returned inner enumerable into its constituent objects for the overall enumeration:
var root = (JContainer)JToken.Parse(jsonFromFile);
var controlRoot = (JContainer)root["Object"];
string parentKey = "";
int groupId = 0;
var query =
controlRoot
.DescendantsAndSelf()
.Where(jt => (jt.Type == JTokenType.Object) || (jt.Type == JTokenType.Array))
.SelectMany(jo =>
{
if (jo.Parent is JProperty)
{
var ParentName = ((JProperty)jo.Parent).Ancestors()
.Where(jt => jt.Type == JTokenType.Property)
.Select(jt => ((JProperty)jt).Name.ToString())
.FirstOrDefault();
if (ParentName == "Object")
{
parentKey = ((JProperty)jo.Parent).AncestorsAndSelf() // Climb up the json container parent/child hierachy
.Select(p => p.SelectToken("NM")) // Get the "parentKey" property in the current parent (if present)
.FirstOrDefault(k => k != null).ToString(); // Return the first one found.
}
if (jo is JObject)
{
// add a property for the parent
var joWork = new JObject(new JProperty("_Parent", parentKey));
// add only the string properties in the current object
joWork.Add(((JObject)jo).Properties()
.Where(p => p.Value.Type == JTokenType.String));
return new[] { joWork };
}
else if (jo is JArray)
{
groupId++;
return from o in jo
let arrayItems = ((JObject)o).Properties().Where(p => p.Value.Type == JTokenType.String).ToList()
where arrayItems.Count > 0
select new JObject(new[]
{
new JProperty("_Parent", parentKey),
new JProperty("_Group", groupId),
}
.Concat(arrayItems));
}
}
return Enumerable.Empty<JObject>();
}
)
.ToList();
Console.WriteLine(JsonConvert.SerializeObject(query, Formatting.Indented));
Here I am using LINQ query syntax inside the SelectMany() method, since it's more compact. The alternative method syntax would be:
else if (jo is JArray)
{
groupId++;
return jo.Select(o =>
{
var arrayItems = ((JObject)o).Properties()
.Where(p => p.Value.Type == JTokenType.String).ToList();
if (arrayItems.Count > 0)
{
var joWork = new JObject();
// add a property for the parent
joWork.Add(new JProperty("_Parent", parentKey));
joWork.Add(new JProperty("_Group", groupId));
// add only the string properties in the current object
joWork.Add(arrayItems);
return joWork;
}
else
{
return null;
}
})
.Where(o => o != null);
}