Jaganathan Bantheswaran12y ago
Accepted answer
Updated Answer:

namespace WpfApplication1

{

    ///

    /// Interaction logic for MainWindow.xaml

    ///

    public partial class MainWindow : Window

    {

        public MainWindow()

        {

            InitializeComponent();

            const string xml = @"





                           ";

            var doc = new XmlDocument();

            doc.LoadXml(xml);

            if (doc.ChildNodes.Count > 0)

            {

                var rootNode = new TreeNode(doc.ChildNodes[0].Name);

                var nodes = TreeNode.Traverse(rootNode, doc.ChildNodes);

                _treeView.ItemsSource = nodes;

            }

        }

    }

    public class TreeNode : IEnumerable<TreeNode>

    {

        private readonly Dictionary<string, TreeNode> _childs = new Dictionary<string, TreeNode>();

        public readonly string Id;

        public TreeNode Parent { get; private set; }

        public TreeNode(string id)

        {

            Id = id;

            Name = id;

        }

        public string Name

        {

            get; set;

        }

        public TreeNode GetChild(string id)

        {

            return _childs[id];

        }

        public void Add(TreeNode item)

        {

            if (item.Parent != null)

            {

                item.Parent._childs.Remove(item.Id);

            }

            item.Parent = this;

            _childs.Add(item.Id, item);

        }

        public IEnumerator<TreeNode> GetEnumerator()

        {

            return _childs.Values.GetEnumerator();

        }

        IEnumerator IEnumerable.GetEnumerator()

        {

            return GetEnumerator();

        }

        public int Count

        {

            get { return _childs.Count; }

        }

        public static TreeNode Traverse(TreeNode treeNode, XmlNodeList nodes)

        {

            if (treeNode == null) throw new ArgumentNullException("treeNode", new Exception("RootNode can't be Null"));

            foreach (XmlNode node in nodes)

            {

                var childNode = new TreeNode(node.Name);

                treeNode.Add(node.ChildNodes.Count > 0 ? Traverse(childNode, node.ChildNodes) : childNode);

            }

            return treeNode;

        }

    }

}
```
<Window x:Class="WpfApplication1.MainWindow"
```
```
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
```
```
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
```
```
        Title="MainWindow" Height="350" Width="525">
```
```
    <Window.Resources>
```
```
        <HierarchicalDataTemplate ItemsSource="{Binding}" x:Key="TvTemplate">
```
```
            <TreeViewItem Header="{Binding Path=Name}"/>
```
```
        HierarchicalDataTemplate>
```
```
    Window.Resources>
```
```
    <StackPanel>
```
```
        <TreeView x:Name="_treeView"
```
```
                          ItemsSource="{Binding}"
```
```
                          ItemTemplate="{StaticResource TvTemplate}" />
```
```
    StackPanel>
```
```
Window>
```
0
Jaganathan Bantheswaran12y ago
You are always welcome.
0
Damian Helaey12y ago
Hi Jaganathan

Thank you for your help this has enabled me moved on with my coding. I will now work on binding some checkboxes - and probably post another question in a couple of weeks
0
Damian Helaey12y ago
0
Damian Helaey12y ago
Hi Jaganathan,
Thank you for your help!
Your TraverseNodes method is quite elegant and recreates the hierarchy
as required. I am working on getting this integrated with my code as I need to
use my Node class instead of the TreeNode class
I have upload my Node class - the copy and paste tool is not usable
0
Jaganathan Bantheswaran12y ago
Hi,

Here is the custom TreeNode implementation.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Xml;

namespace TestConsoleApp
{
class Program
{
private static void Main(string[] args)
{
const string xml = @"

";
var doc = new XmlDocument();
doc.LoadXml(xml);
if (doc.ChildNodes.Count > 0)
{
var rootNode = new TreeNode(doc.ChildNodes[0].Name);
var nodes = TraverseNodes(rootNode, doc.ChildNodes[0].ChildNodes);
Console.ReadKey();
}
}

private static TreeNode TraverseNodes(TreeNode treeNode, XmlNodeList nodes)
{
if (treeNode == null) throw new ArgumentNullException("treeNode", new Exception("RootNode can't be Null"));

foreach (XmlNode node in nodes)
{
var childNode = new TreeNode(node.Name);
treeNode.Add(node.ChildNodes.Count > 0 ? TraverseNodes(childNode, node.ChildNodes) : childNode);
}

return treeNode;
}

}

//Source: http://stackoverflow.com/a/9860455
class TreeNode : IEnumerable
{
private readonly Dictionary _childs = new Dictionary();

public readonly string Id;
public TreeNode Parent { get; private set; }

public TreeNode(string id)
{
Id = id;
}

public TreeNode GetChild(string id)
{
return _childs[id];
}

public void Add(TreeNode item)
{
if (item.Parent != null)
{
item.Parent._childs.Remove(item.Id);
}

item.Parent = this;
_childs.Add(item.Id, item);
}

public IEnumerator GetEnumerator()
{
return _childs.Values.GetEnumerator();
}

IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}

public int Count
{
get { return _childs.Count; }
}
}
}
0