<Sitemap>
  <SitemapData>
    <DisplayName>Home</DisplayName>
    <Path>/</Path>
    <Children>
      <SitemapData>
        <DisplayName>ClientUI</DisplayName>
        <Path>/ClientUI</Path>
        <Children>
          <SitemapData>
            <DisplayName>Scheduling Controls</DisplayName>
            <Path>/ClientUI/Scheduling Controls</Path>
            <Children>
              <SitemapData>
                <DisplayName>Schedule View</DisplayName>
                <Path>/ClientUI/Scheduling Controls/Schedule View</Path>
              </SitemapData>
            </Children>
          </SitemapData>
          <SitemapData>
            <DisplayName>Ribbon Controls</DisplayName>
            <Path>/ClientUI/Ribbon Controls</Path>
            <Children>
              <SitemapData>
                <DisplayName>Ribbon</DisplayName>
                <Path>/ClientUI/Ribbon Controls/Ribbon</Path>
              </SitemapData>
            </Children>
          </SitemapData>
        </Children>
      </SitemapData>
      <SitemapData>
        <DisplayName>ASP.NET</DisplayName>
        <Path>/ASP.NET</Path>
      </SitemapData>
    </Children>
  </SitemapData>
</Sitemap>
        

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Threading;
using System.Windows;
using System.Windows.Resources;
using System.Xml.Linq;
using Intersoft.Client.Framework;
using Intersoft.Client.UI.Navigation;

namespace BreadCrumbLoadOnDemand.ViewModels
{
    public class BreadCrumbViewModel : ViewModelBase
    {
        #region Fields

        private object _expandedItem;
        private string _greetingText;
        private object _processedItem;
        private object _queryResult;
        private string _queryText;
        private Uri _resolvedUri;

        #endregion

        #region Constructor

        public BreadCrumbViewModel()
        {
            //Get the StreamResourceInfo for the XML file
            StreamResourceInfo resourceStream = Application.GetResourceStream(new Uri("/BreadCrumbLoadOnDemand;Component/XML/Sitemap.xml", UriKind.Relative));
            if (resourceStream != null)
            {
                XDocument xdoc = XDocument.Load(resourceStream.Stream, LoadOptions.SetBaseUri);
                //Use the utility method to generate sitemap from XML
                Sitemap = Intersoft.Client.UI.Navigation.UXBreadCrumb.GenerateSitemap(xdoc, "DisplayName", "Path", "Children", null);
            }
        }

        #endregion

        #region BackgroundWorker

        public BackgroundWorker BackgroundWorker { get; set; }

        void BackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker worker = sender as BackgroundWorker;
            if (worker != null)
            {
                SitemapData obj = e.Argument as SitemapData;
                if (obj != null)
                {
                    var dataThread = new Thread(() =>
                    {
                        //This is to simulate request, do not use in production code
                        Thread.Sleep(500);

                        CrossPlatform.BeginInvoke(new Action(() =>
                        {
                            if (!worker.CancellationPending)
                            {
                                this.SearchSitemap(obj);

                                if (this.SitemapData != null && this.SitemapData.Children != null && this.SitemapData.Children.Any())
                                    obj.Children = this.SitemapData.Children;
                                else
                                    obj.Children = null;

                                this.ProcessedItem = obj;
                            }
                        }));
                    });
                    dataThread.Start();

                }
            }
        }

        #endregion

        #region Properties

        public object ExpandedItem
        {
            get { return this._expandedItem; }
            set
            {
                //Destroy current BackgroundWorker to cancel
                if (this.BackgroundWorker != null)
                {
                    this.BackgroundWorker.DoWork -= BackgroundWorker_DoWork;
                    this.BackgroundWorker.CancelAsync();
                    this.BackgroundWorker = null;
                }

                if (this._expandedItem != value)
                {
                    this._expandedItem = value;
                    SitemapData obj = value as SitemapData;
                    if (obj != null)
                    {
                        //Wrap the thread to a BackgroundWorker to support cancellation.
                        this.BackgroundWorker = new BackgroundWorker { WorkerSupportsCancellation = true };
                        this.BackgroundWorker.DoWork += BackgroundWorker_DoWork;
                        this.BackgroundWorker.RunWorkerAsync(obj);
                    }

                    OnPropertyChanged("ExpandedItem");
                }
            }
        }

        public object ProcessedItem
        {
            get { return this._processedItem; }
            set
            {
                if (this._processedItem != value)
                {
                    this._processedItem = value;
                    OnPropertyChanged("ProcessedItem");
                }
            }
        }

        public object QueryResult
        {
            get { return this._queryResult; }
            set
            {
                if (this._queryResult != value)
                {
                    this._queryResult = value;
                    OnPropertyChanged("QueryResult");
                }
            }
        }

        public string QueryText
        {
            get { return this._queryText; }
            set
            {
                if (this._queryText != value)
                {
                    this._queryText = value;
                    var dataThread = new Thread(() =>
                    {
                        //This is to simulate request, do not use in production code
                        Thread.Sleep(500);

                        CrossPlatform.BeginInvoke(new Action(() =>
                        {
                            this.QueryResult = this.SearchQueryTextFromSitemap(this._queryText);
                        }));
                    });
                    dataThread.Start();
                }
                else
                {
                    this._queryText = value;
                }
                OnPropertyChanged("QueryText");
            }
        }

        public SitemapData ResultSitemapData { get; set; }

        public IEnumerable<SitemapData> Sitemap { get; set; }

        public string GreetingText
        {
            get { return this._greetingText; }
            set
            {
                if (this._greetingText != value)
                {
                    this._greetingText = value;
                    OnPropertyChanged("GreetingText");
                }
            }
        }

        public Uri ResolvedUri
        {
            get { return this._resolvedUri; }
            set
            {
                if (this._resolvedUri != value)
                {
                    this._resolvedUri = value;
                    OnPropertyChanged("ResolvedUri");
                    //After ResolvedUri has been set, find the appropriate display name to be displayed to GreetingText
                    this.FindDisplayNameRecursive(this.Sitemap);
                }
            }
        }

        public SitemapData SitemapData { get; set; }

        #endregion

        #region Methods

        private void FindDisplayNameRecursive(IEnumerable sitemap)
        {
            if (sitemap != null)
            {
                foreach (SitemapData sitemapData in sitemap)
                {
                    if (sitemapData.NavigateUri == this.ResolvedUri)
                    {
                        this.GreetingText = "You're now at: " + sitemapData.DisplayName;
                        break;
                    }

                    if (sitemapData.Children != null)
                        this.FindDisplayNameRecursive(sitemapData.Children);
                }
            }
        }

        private void SearchSitemap(SitemapData sitemapData)
        {
            this.RecursiveSitemapSearch(sitemapData, this.Sitemap);
        }

        private void RecursiveSitemapSearch(SitemapData sitemapData, IEnumerable<SitemapData> collection)
        {
            foreach (SitemapData data in collection)
            {
                if (sitemapData.NavigateUri == data.NavigateUri)
                    this.SitemapData = data;

                if (data.Children != null)
                    this.RecursiveSitemapSearch(sitemapData, data.Children);
            }
        }

        private object SearchQueryTextFromSitemap(string queryText)
        {
            ObservableCollection<SitemapData> collection = new ObservableCollection<SitemapData>();
            this.SearchQueryTextRecursive(queryText, this.Sitemap, collection);
            return collection;
        }

        private void SearchQueryTextRecursive(string queryText, IEnumerable<SitemapData> collection, ObservableCollection<SitemapData> returnCollection)
        {
            foreach (SitemapData data in collection)
            {
                if (data.NavigateUri != null && data.NavigateUri.OriginalString.StartsWith(queryText))
                    returnCollection.Add(data);

                if (data.Children != null)
                    this.SearchQueryTextRecursive(queryText, data.Children, returnCollection);
            }
        }

        #endregion
    }
}