wpf数据自动树结构

　　在项目中，时常会遇到存在上下级关系的数据。在呈现方面，按照传统方法，不得不组装TreeNode之后添加到TreeView 中，已实现树形数据的显示。如果项目中需要多处使用树，毫无疑问这将存在巨大的代码冗余，会有无数针对不同实体组件TreeNode的代码出现，整体风格糟糕至极。

　　在近期的项目中，很多地方拥有这样的上下级关系，如下图所示，可以清楚的看出它们直接的关系

　　在数据的查询上，一般对于Oracle不太熟悉的人，可能就会采用 in或者exist关键字来进行筛选， 实际上Oracle有已经有递归查询的语法存在，对于Oracle不太熟悉的看官，可以百度一下。

这里列出了示例：

select t.project_id,t.project_name,t.p_project_id,t.p_project_name,t.category from sys_project_info s start with s.category in (10,11,21) connect by prior s.project_id=s.p_project_id and s.project_name = s.p_project_name;

　　

　　到这里数据的提取部分就已经完成，剩下的就是树形数据的组建过程，也就是数据的呈现。归根结底还是递归，在这里只是对递归过程进行了封装，可以直接移植到WPF或者Silverlight项目中，代码如下：

using Microsoft.Practices.Prism.ViewModel;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Runtime.Serialization;
using System.Text;

namespace SysManager.Utility
{
    public class TreeNode<T> : NotificationObject where T : BaseEntity
    {
        private T _parentNode;
        private T _currentNode;
        private bool _isChecked;
        private bool _canChecked;

        /// <summary>
        /// 父节点
        /// </summary>
        public dynamic Key { get; set; }

        /// <summary>
        /// 子节点
        /// </summary>
        public ObservableCollection<TreeNode<T>> ChildrenNodes { get; set; }

        /// <summary>
        /// 是否允许被选中
        /// </summary>
        public bool CanChecked
        {
            get { return _canChecked; }
            set
            {
                if (_canChecked == value)
                    return;
                _canChecked = value;
                RaisePropertyChanged("CanChecked");
            }
        }

        /// <summary>
        /// 是否处于被选中状态
        /// </summary>
        public bool IsChecked
        {
            get { return _isChecked; }
            set
            {
                if (_isChecked == value)
                    return;
                _isChecked = value;
                RaisePropertyChanged("IsChecked");
            }
        }
        /// <summary>
        /// 当前选中节点
        /// </summary>
        public T CurrentNode
        {
            get { return _currentNode; }
            set
            {
                if (_currentNode == value)
                    return;
                _currentNode = value;
                RaisePropertyChanged("CurrentNode");
            }
        }
        /// <summary>
        /// 当前节点的父级节点
        /// </summary>
        public T ParentNode
        {
            get { return _parentNode; }
            set
            {
                if (_parentNode == value)
                    return;
                _parentNode = value;
                RaisePropertyChanged("ParentNode");
            }
        }

        public TreeNode()
        {
            this.CanChecked = true;
        }

        static TreeNode<T> staticNode;

        /// <summary>
        /// 将数据组织成一个拥有上下级管理的树形结构数据集合
        /// </summary>
        /// <typeparam name="TKey">主键的数据类型</typeparam>
        /// <param name="nodeSource">执行过GroupBy语句的数据源</param>
        /// <param name="resultTreeNode">结果数据</param>
        /// <param name="keyName">子节点标识字段名称</param>
        /// <param name="parentKeyName">父节点标识字段名称</param>
        /// <param name="orderByKeys"></param>
        /// <returns>已生成的树形结构实体</returns>
        public TreeNode<T> GenerateTreeNodes<TKey>(IEnumerable<IGrouping<TKey, T>> nodeSource, TreeNode<T> resultTreeNode, string keyName, string parentKeyName)
        {
            var orderedSource = nodeSource.OrderBy(groupList => groupList.Key);
            foreach (IGrouping<TKey, T> item in orderedSource)
            {
                var listChildrenNode = new ObservableCollection<TreeNode<T>>();
                object propertyParentValue = null;

                foreach (var child in item)
                {
                    //get  children id 
                    object propertyValue = GetCurrentItemPropertyValue(keyName, child);
                    //get parent id 
                    if (propertyParentValue == null)
                        propertyParentValue = GetCurrentItemPropertyValue(parentKeyName, child);

                    if (propertyValue != propertyParentValue)
                    {
                        T parentNodeInstance = null;
                        if (propertyParentValue != null)
                        {
                            var nodeParent = nodeSource.Where(x => x.Key.ToString() == propertyParentValue.ToString()).FirstOrDefault();
                            if (nodeParent != null)
                                parentNodeInstance = nodeParent.FirstOrDefault();
                        }
                        var node = new TreeNode<T>() { CurrentNode = child, Key = propertyValue, ChildrenNodes = new ObservableCollection<TreeNode<T>>(), ParentNode = parentNodeInstance };
                        listChildrenNode.Add(node);
                    }

                }

                TreeNode<T> parentNode = null;
                foreach (var root in listChildrenNode)
                {
                    staticNode = null;
                    parentNode = FindParentNode(resultTreeNode, item.Key);
                    if (parentNode != null)
                        break;
                }
                if (parentNode != null)
                {
                    parentNode.ChildrenNodes = listChildrenNode;
                }
                else
                    listChildrenNode.ToList().ForEach(childNode => resultTreeNode.ChildrenNodes.Add(childNode));

            }
            return resultTreeNode;
        }

        /// <summary>
        /// 将一个拥有上下级关系的Tree转换为列表
        /// </summary>
        public IEnumerable TreeNode2LinkedList { get; private set; }
        /// <summary>
        /// 将treenode转换为列表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="originalSource"></param>
        public void TreeNodeToLinkedList(TreeNode<T> originalSource)
        {
            if (originalSource != null && originalSource.ChildrenNodes != null)
            {
                if (originalSource.CurrentNode != null)
                {
                    if (TreeNode2LinkedList == null)
                        TreeNode2LinkedList = new List<T>();
                    (TreeNode2LinkedList as List<T>).Add(originalSource.CurrentNode);
                }
                foreach (var item in originalSource.ChildrenNodes)
                {
                    TreeNodeToLinkedList(item);
                }
            }
        }

        private static object GetCurrentItemPropertyValue(string keyName, T child)
        {
            var property = child.GetType().GetProperties().Where(prop => prop.Name == keyName).FirstOrDefault();
            object propertyValue = null;
            if (property != null)
                propertyValue = property.GetValue(child, null);
            return propertyValue;
        }

        /// <summary>
        /// 寻找当前节点的父级节点
        /// </summary>
        /// <param name="rootNode">当前节点</param>
        /// <param name="key">节点的Key</param>
        /// <returns>父级节点</returns>
        private TreeNode<T> FindParentNode(TreeNode<T> rootNode, dynamic key)
        {

            if (rootNode.ChildrenNodes == null)
                return rootNode;
            foreach (var children in rootNode.ChildrenNodes)
            {
                if (children.Key == key)
                {
                    staticNode = children;
                    break;
                }
                else
                    if (staticNode == null)
                        FindParentNode(children, key);
            }
            if (rootNode.Key != null && (int)rootNode.Key == key)
                return rootNode;

            return staticNode;

        }
    }
}

　　

//调用方法
var treeNode = new TreeNode<SysProjectInfoEntity>();
                    treeNode.GenerateTreeNodes<decimal?>(result.OfType<SysProjectInfoEntity>().GroupBy(proj => proj.ParentProjectId), treeNode, "ProjectId", "ParentProjectId");