C#中一种通用的树的生成方式

在写程序时，经常要用到树的这种结构，如果是做界面编程，那么TreeView是一个不错的选择，几个设置就能把数据绑定好，但是如果自己写类呢？相对就麻烦一点。

这里讨论一下如何快速建立自己的树型结构，即怎么把建树的方法抽离出来加以复用。

代码的复用，不外乎类，接口，泛型。

先考虑用接口来实现，定义一个ITreeNode 然后每一个要建立树型结构的结点去实现？感觉不大好，因为你要定义比如Parent Children等一系列的东西，很是很麻烦，每一个实现起来也很困难。

那抽像类？抽象类的继承到是方便，但是在实际使用中涉及各种类型转换，代码写起来不爽。

泛型呢？泛型的结构又过于笼统 ，但是可以折衷一下，就是用泛型定义一个结点的类

（小弟写代码方式都相对“妥协”，一位大人说的，各位将就着看哈）

 

 1  namespace Soway.DB.Tree
 2 {
 3      public  class  TreeNode<T>
 4     {
 5 
 6          public T Data {  get;  set; }
 7          public TreeNode<T> Parent {  get;  set; }
 8          public List<TreeNode<T>> Children {  get;  set; }
 9     }
10 }

 

结点类定义好了以后，就要去实现一个 TreeFactory ，将建树的通用算法提出来。

 

namespace Soway.DB.Tree
{

    
    
     public  class TreeFactory <T>
    { 
public List<TreeNode<T>> CreateTreeByLevel
            (List<T> Items )
        {
             //////
        }
    }
}

这里的我的方法名已经默认为ByLevel ，即按层建立树，这样，新的问题又出现了：

1.怎么保证输入值Items是已经按层遍立建立好的结点？

2.怎么分层？即怎么区分树的父结点，子结点，同级结点之间的关系 ？

这些问题其实都与泛型的具体类型有关，但如果把具体类型约束了，那就违反我们本意了。

走一步算一步，先这样，把树结点之间的关系定义出来，算是一个枚举吧：

 

namespace Soway.DB.Tree
{
     public  enum  TeeNodeCompareResult
    {
         ///   <summary>
         ///  树结点
         ///   </summary>
        Parent,
         ///   <summary>
         ///  子结点
         ///   </summary>
        Child,
         ///   <summary>
         ///  下一个同级结点
         ///   </summary>
        NextNode,
         ///   <summary>
         ///  前一个同级结点
         ///   </summary>
        PreNode,
         ///   <summary>
         ///  同一个结点
         ///   </summary>
        EquealNode ,
         ///   <summary>
         ///  下一层的结点
         ///   </summary>
        NexLevelNode

    }
}

 

有了这个关系以后，于是有了进一步的想法，考虑传递给TreeFactory一个委托，可以通过这个来得到两个结点之间比较关系：

 

namespace Soway.DB.Tree
{
     public  delegate TeeNodeCompareResult TeeNodeCompare<T>(T child, T parent);
}

这样，我们的TreeFactory里多了一个泛型委托的成员。。。

 

    private TeeNodeCompare<T> compare;

         public TreeFactory(Tree.TeeNodeCompare<T> Compare)
        {
             this.compare = Compare;

        }

 

现在，当这个泛型委托处理好了以后，我们下一步问题也好办了，就是将输入的Items进行按层排序，这时，只要有一个Comparison<T>（）的实现 ，我直接调用 List<T>.Sort(Comprarion<T>)即可了

下面给出这个Comparation<T>的实现 ：

 

  private  int CompareResult(T ob1, T ob2)
        {
             switch (compare(ob1, ob2))
            {
                 case TeeNodeCompareResult.Child:
                 case TeeNodeCompareResult.NextNode:
                 case TeeNodeCompareResult.NexLevelNode:
                     return  1;
                 case TeeNodeCompareResult.Parent :
                 case TeeNodeCompareResult.PreNode:
                     return - 1;
                 default :
                     return  0;
            }
          
                
        }

好，这些基础工作做完以后，建树的就容易了：

 

       ///   <summary>
         ///  按层建立树
         ///   </summary>
         ///   <param name="Items"> 建立树的集合 </param>
         ///   <returns> 建立好的树结构 </returns>
         public List<TreeNode<T>> CreateTreeByLevel
            (List<T> Items )
        {
            Items.Sort( new Comparison<T>( this.CompareResult));
            List<TreeNode<T>> result =  new List<TreeNode<T>>();
            TreeNode<T> lastNode = null;
            Queue<TreeNode<T>> queue =  new Queue<TreeNode<T>>();
            TreeNode<T> currentNode= null;
             var current = result;
             if (Items.Count >  0)
            {



                   for ( int i =  0; i < Items.Count ; i++)
                {


                    
                    TreeNode<T> AddedNode =  new  TreeNode<T>(){Data=Items[i],
                        Parent =  null,Children =  new List<TreeNode<T>>()}; // 生成要添加的数据 

                    queue.Enqueue(AddedNode); // 入队
                       // 看是否到了下一层的结点
                     if (lastNode !=  null &&
                        (compare(AddedNode.Data, lastNode.Data) == Tree.TeeNodeCompareResult.Child
                         || compare(AddedNode.Data, lastNode.Data) == Tree.TeeNodeCompareResult.NexLevelNode) // 下一层：即结点是子结点或是下一层结点
                        )
                    {
                        currentNode = queue.Dequeue();
                       
                    }
                     // 找到对应的父结点
                     while (currentNode !=  null 
                        &&
                        compare(AddedNode.Data, currentNode.Data) != TeeNodeCompareResult.Child
                        )
                    {
                        currentNode = queue.Dequeue();
                    }
                     if (currentNode != null && compare(AddedNode.Data, currentNode.Data) != TeeNodeCompareResult.EquealNode)
                    {
                        AddedNode.Parent = currentNode;
                        current = currentNode.Children;
                    }
                    current.Add(AddedNode);
                    lastNode = AddedNode;
                }
            }
             return result;
       

        }

 

下面是一个使用的Demo ^_^

 

// 类：
{
    [Table(Name= " Auth ")]    
     public  class Auth
    {
        [Column(IsKey= true)]
         public  string Code {  get;  set; }
         public  string Name {  get;  set; }
         public String Url {  get;  set; }
         public  string View {  get;  set; }
         public  string Action {  get;  set; }
         public  string Text {  get;  set; }
         public  string Image {  get;  set; }


         public  override  string ToString()
        {
             return Code +  "   " + Name;
        }

         
  
    }
// 比较结点的关系：
  static Soway.DB.Tree.TeeNodeCompareResult compare(Auth ob1, Auth ob2)
        {

             if (ob1.Code == ob2.Code)
                 return TeeNodeCompareResult.EquealNode;
             if (ob1.Code.Length > ob2.Code.Length)
                 if (ob1.Code.IndexOf(ob2.Code) ==  0)
                     return TeeNodeCompareResult.Child;
                 else
                     return TeeNodeCompareResult.NexLevelNode;
             else  if (ob1.Code.Length < ob2.Code.Length)
                 return TeeNodeCompareResult.Parent;
             else  if (ob1.Code.CompareTo(ob2.Code) <  0)
                 return TeeNodeCompareResult.PreNode;
             else
                 return TeeNodeCompareResult.NextNode;
                

        }


/// 主函数中
  var c =  new Soway.DB.DBContext(builder.ToString());
             var items = c.Get<Auth  >(); // 初始化
     var tree =  new TreeFactory<Auth>( new TeeNodeCompare<Auth>(compare)).CreateTreeByLevel(items); // 建立树型结构