Flatten list problem - cannot be inferred from usage

[Techno]

So I have a List<> of items.
each item has a list of other items (grandparent > parent > child > children etc...)

I want to now flatten the list so all the items are in just one list.

how can I do this?

I tried:

List<Items> flat = structuredItems.SelectMany(m => m);

but I get a compiler error:

Error	202	The type arguments for method 'System.Linq.Enumerable.SelectMany<TSource,TResult>(System.Collections.Generic.IEnumerable<TSource>, System.Func<TSource,System.Collections.Generic.IEnumerable<TResult>>)' cannot be inferred from the usage. Try specifying the type arguments explicitly.

[jmcilhinney]

Your lambda doesn't make sense. The point of SelectMany is to start with one list, get a list from each item in that list and then join them all together. Your lambda doesn't get a list from the item - it just gets the item itself - so what's the point? If it worked then you'd just end up with the same list as you started with.

Does your data form a simple hierarchical tree or are there potentially some circular references in there? If it's the former then you can use SelectMany correctly inside a Do Until loop but if it's the latter then it's going to be more complex.

[Techno]

Thanks. must be the lack of sleep i have had showing my errors.

my data from a simple hierachical tree does not have any circular references.
So how can I flatten the list?

so my MenuItem object contains some strings and also a List<MenuItem> of children.

[jmcilhinney]

I haven't tested this but it seems to me that you should be able to flatten a hierarchical list by calling SelectMany in a loop like so:

private ToolStripMenuItem[] GetAllMenuItems(IEnumerable<ToolStripMenuItem> menuItems)
{
    // Start with the top-level menu items.
    var allMenuItems = menuItems.ToList();
 
    // Get the first level of children.
    var childMenuItems = allMenuItems.SelectMany(item => item.DropDownItems.Cast<ToolStripMenuItem>()).ToArray();
 
    // Keep going as long as there are children to add.
    while (childMenuItems.Length > 0)
    {
        // Add the children to the list.
        allMenuItems.AddRange(childMenuItems);
 
        // Get the next level of children.
        childMenuItems = childMenuItems.SelectMany(item => item.DropDownItems.Cast<ToolStripMenuItem>()).ToArray();
    }
 
    return allMenuItems.ToArray();
}

I have used ToolStripMenuItem there but it will work for any type that has a property whose type is a collection of itself.

[AceInfinity]

You could loop through the parent collection that contains each sub collection:

List<List<int>> parentList = new List<List<int>>(new List<int>[]
{
    new List<int>(new int[] { 1, 2, 3 }),
    new List<int>(new int[] { 1, 2, 3 }),
    new List<int>(new int[] { 1, 2, 3 })
});
 
List<int> joinedList = new List<int>();
parentList.ForEach(l => joinedList.AddRange(l));
Console.WriteLine(string.Join(", ", joinedList));

And add the ranges to the final container.. Without a glance on how the structure of this "tree" is for each group/collection of items, anybody that gives you your solution could've just arrived there by luck.

[jmcilhinney]

You could loop through the parent collection that contains each sub collection:

List<List<int>> parentList = new List<List<int>>(new List<int>[]
{
    new List<int>(new int[] { 1, 2, 3 }),
    new List<int>(new int[] { 1, 2, 3 }),
    new List<int>(new int[] { 1, 2, 3 })
});
 
List<int> joinedList = new List<int>();
parentList.ForEach(l => joinedList.AddRange(l));
Console.WriteLine(string.Join(", ", joinedList));

And add the ranges to the final container.

Unless I'm missing something, that is only going to work for one level. You need to add some iteration or recursion if you want to support an arbitrary number of levels.

Without a glance on how the structure of this "tree" is for each group/collection of items, anybody that gives you your solution could've just arrived there by luck.

Not really. A tree is a tree. If you're talking about a class that has a collection property of its own type then the pattern will be the same regardless of the actual definition of that class. The only thing that would change would be the type and member names.

[AceInfinity]

Unless I'm missing something, that is only going to work for one level. You need to add some iteration or recursion if you want to support an arbitrary number of levels.

Yes: "Without a glance on how the structure of this "tree" is for each group/collection of items, anybody that gives you your solution could've just arrived there by luck."

You quoted and replied to this, so it didn't go without notice, but what you missed was my meaning behind why I posted that, before you took it into your own definition for what I meant.

Not really. A tree is a tree. If you're talking about a class that has a collection property of its own type then the pattern will be the same regardless of the actual definition of that class. The only thing that would change would be the type and member names.

You just said for yourself (in the same post) that it would only work for one level, so a tree is a tree, but as I said, It depends on the structure of the "tree". It can be many levels, or just one level... Please don't reply debating semantics that a tree is a tree regardless of it's levels, and the structure is still the same structure, just with different levels, because this is what I originally meant when I posted, when I referenced the "structure"; the levels or depth to the overall branches of the "tree".

For all we know without actually seeing the tree, it could just be a leftover stump, cut down many years ago with no branches. If I was to take this analogy further, it could be a spruce tree, an apple tree, etc... There's no telling the structure of the tree, just because "it's a tree", and the same thing applies here.

If it was really complex with many branches and different numbers of branches in some areas, then he could introduce a recursive function to retrieve the items. But I still haven't gotten a clear picture of what data he's dealing with.

~Ace

[jmcilhinney]

For all we know without actually seeing the tree, it could just be a leftover stump, cut down many years ago with no branches. If I was to take this analogy further, it could be a spruce tree, an apple tree, etc... There's no telling the structure of the tree, just because "it's a tree", and the same thing applies here.

If it was really complex with many branches and different numbers of branches in some areas, then he could introduce a recursive function to retrieve the items. But I still haven't gotten a clear picture of what data he's dealing with.

~Ace

Well, we know this much, because we were told at the outset:

each item has a list of other items (grandparent > parent > child > children etc...)

The code I provided will work regardless of the number of levels and there was no luck involved in that.