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");