Recursive adding XML into TreeView

Question

I'm trying to import an XML file of nodes into the same node structure in a TreeView using C#. I have found a lot of example that use a single node structure, but have had a lot of issues traversing the XML file and populating the TreeView with it. This is a sample of the XML file:

<?xml version="1.0"?>
<xmlRoot>
<ProductGroup>
    <Group> 
      <GroupName>Soda</GroupName>
        <Classifications>
            <Classification>
                <ClassificationName>Regular</ClassificationName>
                    <Containers>
                        <Container>
                            <ContainerType>Can</ContainerType>
                            <ContainerName>SmallCan</ContainerName>
                        </Container>
                        <Container>
                            <ContainerType>bottle</ContainerType>
                            <ContainerName>SmallBottle</ContainerName>
                        </Container>
                    </Containers>
            </Classification>
            <Classification>
                <ClassificationName>Diet</ClassificationName>
                    <Containers>
                        <Container>
                            <ContainerType>Can</ContainerType>
                            <ContainerName>SmallCan</ContainerName>
                        </Container>
                    </Containers>
            </Classification>
        </Classifications>
    </Group>
    <Group> 
      <GroupName>Water</GroupName>
        <Classifications>
            <Classification>
                <ClassificationName>Regular</ClassificationName>
                    <Containers>
                        <Container>
                            <ContainerType>Bottle</ContainerType>
                            <ContainerName>EcoBottle</ContainerName>
                        </Container>
                    </Containers>
            </Classification>
        </Classifications>
    </Group>
</ProductGroup>
</xmlRoot>

I've tried using something like this:

treProducts.Nodes.Clear();
XDocument xdoc = XDocument.Load("ProductDocument.xml");
foreach (XElement groupElement in xdoc.Descendants("Group"))
{
    treProducts.Nodes.Add(groupElement.Element("GroupName").Value);
    treProducts.SelectedNode = treProducts.Nodes[groupElement.Element("GroupName").Value];
    foreach (XElement ClassificationElement in groupElement.Descendants("Classification"))
    {
        treProducts.SelectedNode.Nodes.Add(groupElement.Element("ClassificationName").Value);
        treProducts.SelectedNode = treProducts.Nodes[groupElement.Element("ClassificationName").Value];
        foreach (XElement ContainerElement in groupElement.Descendants("Container"))
        {
            treProducts.SelectedNode.Nodes.Add(ContainerElement.Element("ContainerName").Value);
        }
    }
}

I'm trying to get the tree to show:

Soda
    Regular
        SmallCan
        SmallBottle
    Diet
        SmallCan
Water
    Regular
        EcoBottle

...but the tree is only showing Soda and it seems to skip the rest, except if I comment out the nested foreach statements, it will show Soda and Water. There's something wrong with the syntax I'm using and I'm wondering if someone who understands Linq better can help see where the code is wrong.

Answer 1

I suggest recursion

void AddNodes(XElement parentElement, TreeNode parent = null)
{
    Queue<XElement> queue = new Queue<XElement>(parentElement.Elements());
    while (queue.Count > 0)
    {
        TreeNode child = parent;
        XElement element = queue.Dequeue();
        if (!element.HasElements)
        {
            string value = element.Value;
            element = (XElement)element.NextNode;
            if (null != element && !element.HasElements)
                value = element.Value;

            if (null == parent)
                treeView1.Nodes.Add(child = new TreeNode(value));
            else
                parent.Nodes.Add(child = new TreeNode(value));
            child.Expand();
            element = queue.Dequeue();
        }
        AddNodes(element, child);
    }
}

AddNodes(XElement.Load("ProductDocument.xml"));

Note: dbc's answer is probably better if your XML structure is likely to change, but if you are given it as it currently stands, and it won't change - then this will slurp it right into the tree quickly, without a lot of overhead.

Answer 2

The reason this is complicated is that your tree node hierarchy does not correspond 1-1 to your XML hierarchy. In situations like this, I suggest introducing intermediate classes to provide a view into the base XML model data. In WPF these classes would be the View Model, but the windows forms TreeView doesn't support data binding. Despite this, the abstraction of a view model is useful here.

First, some basic view model interfaces and classes to tie together TreeNode and XElement hierarchies:

public interface ITreeNodeViewModel
{
    string Name { get; }

    string Text { get; }

    object Tag { get; }

    object Model { get; }

    IEnumerable<ITreeNodeViewModel> Children { get; }
}

public abstract class TreeNodeViewModel<T> : ITreeNodeViewModel
{
    readonly T model;

    public TreeNodeViewModel(T model)
    {
        this.model = model;
    }

    public T Model { get { return model; } }

    #region ITreeNodeProxy Members

    public abstract string Name { get; }

    public abstract string Text { get; }

    public virtual object Tag { get { return this; } } 

    public abstract IEnumerable<ITreeNodeViewModel> Children { get; }

    #endregion

    #region ITreeNodeViewModel Members

    object ITreeNodeViewModel.Model
    {
        get { return Model; }
    }

    #endregion
}

public abstract class XElementTreeNodeViewModel : TreeNodeViewModel<XElement>
{
    public XElementTreeNodeViewModel(XElement node) : base(node) {
        if (node == null)
            throw new ArgumentNullException();
    }

    public XNamespace Namespace { get { return Model.Name.Namespace; } }

    public override string Name
    {
        get { return Model.Name.ToString();  }
    }
}

Next, a couple extension classes:

public static class TreeViewExtensions
{
    public static void PopulateNodes(this TreeView treeView, IEnumerable<ITreeNodeViewModel> viewNodes)
    {
        treeView.BeginUpdate();
        try
        {
            treeView.Nodes.PopulateNodes(viewNodes);
        }
        finally
        {
            treeView.EndUpdate();
        }
    }

    public static void PopulateNodes(this TreeNodeCollection nodes, IEnumerable<ITreeNodeViewModel> viewNodes)
    {
        nodes.Clear();
        if (viewNodes == null)
            return;
        foreach (var viewNode in viewNodes)
        {
            var name = viewNode.Name;
            var text = viewNode.Text;
            if (string.IsNullOrEmpty(text))
                text = name;
            var node = new TreeNode { Name = name, Text = text, Tag = viewNode.Tag };
            nodes.Add(node);
            PopulateNodes(node.Nodes, viewNode.Children);
            node.Expand();
        }
    }
}

public static class XObjectExtensions
{
    public static string TextValue(this XContainer node)
    {
        if (node == null)
            return null;
        //return string.Concat(node.Nodes().OfType<XText>().Select(tx => tx.Value));  c# 4.0
        return node.Nodes().OfType<XText>().Select(tx => tx.Value).Aggregate(new StringBuilder(), (sb, s) => sb.Append(s)).ToString();
    }

    public static IEnumerable<XElement> Elements(this IEnumerable<XElement> elements, XName name)
    {
        return elements.SelectMany(el => el.Elements(name));
    }
}

Next, view models for the three levels of your tree:

class ContainerViewModel : XElementTreeNodeViewModel
{
    public ContainerViewModel(XElement node) : base(node) { }

    public override string Text
    {
        get
        {
            return Model.Element(Namespace + "ContainerName").TextValue();
        }
    }

    public override IEnumerable<ITreeNodeViewModel> Children
    {
        get { return Enumerable.Empty<ITreeNodeViewModel>(); }
    }
}

class ClassificationViewModel : XElementTreeNodeViewModel
{
    public ClassificationViewModel(XElement node) : base(node) { }

    public override string Text
    {
        get
        {
            return Model.Element(Namespace + "ClassificationName").TextValue();
        }
    }

    public override IEnumerable<ITreeNodeViewModel> Children
    {
        get
        {
            return Model.Elements(Namespace + "Containers").Elements<XElement>(Namespace + "Container").Select(xn => (ITreeNodeViewModel)new ContainerViewModel(xn));
        }
    }
}

class GroupViewModel : XElementTreeNodeViewModel
{
    public GroupViewModel(XElement node) : base(node) { }

    public override string Text
    {
        get
        {
            return Model.Element(Namespace + "GroupName").TextValue();
        }
    }

    public override IEnumerable<ITreeNodeViewModel> Children
    {
        get
        {
            return Model.Elements(Namespace + "Classifications").Elements<XElement>(Namespace + "Classification").Select(xn => (ITreeNodeViewModel)new ClassificationViewModel(xn));
        }
    }
}

Now, building your tree becomes quite simple:

        var xdoc = XDocument.Load("ProductDocument.xml");
        var ns = xdoc.Root.Name.Namespace;
        treeView1.PopulateNodes(xdoc.Root.Elements(ns + "ProductGroup").Elements(ns + "Group").Select(xn => (ITreeNodeViewModel)new GroupViewModel(xn)));

And the result:

Later, if you wish to add editing functionality to your tree, you can add the appropriate methods to ITreeNodeViewModel -- for instance, a setter method for Text. Since the ITreeNodeViewModel has saved itself in the TreeNode.Tag the appropriate methods will be available.

Answer 3

You are using the wrong variable in your loop over the Classification Elements. Replace groupElement with ClassificationElement inside the loop.

Change:

foreach (XElement ClassificationElement in groupElement.Descendants("Classification"))
{
    // groupElement.Element("ClassificationName") is null:
    treProducts.SelectedNode.Nodes.Add(groupElement.Element("ClassificationName").Value);
    ...
}

to

foreach (XElement ClassificationElement in groupElement.Descendants("Classification"))
{
treProducts.SelectedNode.Nodes.Add(ClassificationElement.Element("ClassificationName").Value);
    ...
}