TreeView 节点

       最近公司来了一个小的项目。项目组成员就六个。几个新人，项目经理也不知道看没有看式样。就把一个权限设置页面分给了一个新人来做。那个新人能力不是太好，项目经理也不管。分Task，也不管别人会不会。二话不说，上来就开工。

       这个新人做了两天都没有做出来。于是来求助我。花了一个多小时，总算搞定了。看了看代码，有些地方还是很值得对C#和JSON不了解的童鞋们借鉴的。今天把代码分享出来。

       先说说这个权限生成的几个需求。

       数据源是从数据库读出来的。数据的结构是这样的。有个treePath,里面的存的数据是这样的。

       通过“/”表明数据的组织层次结构，也就是说如果没有“/”就表明是根节点，如果有一个“/”就表明是第二层结构。这样以此类推。每一个“/”前数据表明其父节点是哪一个。就好比这样的一对数据：

       10001

       10001/10002 

       10001/10002/1003

       10001/10003/1003

       20001

       20001/20002

       组织结构就如下了：

       

        相信大家都明白了，接下来看看我们最后要生成的结果图：

                

           好了生成的图大家也明白了。就是这样的树状图。

           下面我来说说我们实现的代码思路。首先把数据从库里面读出来。然后分析数据，最后生成JOSN对象文件，然后前台进行分析这个JSON对象数据。最后生成我们的树状图。

            我们直接来看看代码：

            代码中我定义了一个两个类，用来存储数据的。请看这两个类：

           

/// <summary>
/// 组织数据
/// </summary>
public class Organization
{
    public string OrganKey { get; set; }

    public string OrganName { get; set; }

    public string TreePath { get; set; }

    public Organization(string organKey, string organName, string treePath)
    {
        this.OrganKey = organKey;
        this.OrganName = organName;
        this.TreePath = treePath;
    }
}

/// <summary>
/// 最终的数据结构类型
/// </summary>
public class OrganizationResult
{

    private List<OrganizationResult> lstChildren = new List<OrganizationResult>();

    /// <summary>
    /// 主键KEY
    /// </summary>
    public string Key { get; set; }

    /// <summary>
    /// 主键Name
    /// </summary>
    public string Name { get; set; }

    /// <summary>
    /// 获取字节点的个数
    /// </summary>
    /// <returns></returns>
    public int GetChildNodesCount()
    {
        return lstChildren.Count;
    }

    public string levelKey { get; set; }

    /// <summary>
    /// 构造初始化
    /// </summary>
    /// <param name="key"></param>
    /// <param name="name"></param>
    /// <param name="levelKey"></param>
    public OrganizationResult(string key, string name, string levelKey)
    {
        this.Key = key;
        this.Name = name;
        this.levelKey = levelKey;
    }

    /// <summary>
    /// 添加子节点
    /// </summary>
    /// <param name="child"></param>
    public void AddChildNodes(OrganizationResult child)
    {
        this.lstChildren.Add(child);
    }

    /// <summary>
    /// 根据路径获取节点
    /// </summary>
    /// <param name="index"></param>
    /// <returns></returns>
    public OrganizationResult GetChildNodesByIndex(int index)
    {
        if (this.GetChildNodesCount() < index)
        {

            return null;
        }
        else
        {
            return lstChildren[index];
        }
    }

    /// <summary>
    /// 获取所有的子节点
    /// </summary>
    /// <returns></returns>
    public List<OrganizationResult> GetChildNodes()
    {
        return lstChildren;
    }
}

              这个OrganizationResult是最终存放我们要的数据类。
              下面是我们的数据处理方法：(请看代码)

public partial class Index : System.Web.UI.Page
{
    /// <summary>
    /// 数据集合
    /// </summary>
    private List<Organization> lstData;

    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            this.SetOrganziationData();

            List<OrganizationResult> lstResult = this.ResolveOrganization(lstData);

            this.CreateJsonFile(this.CreateJson(lstResult));
        }
    }

    #region 组织架构的分析
    /// <summary>
    /// 解析组织架构
    /// </summary>
    /// <param name="lstData"></param>
    /// <returns></returns>
    private List<OrganizationResult> ResolveOrganization(List<Organization> lstData)
    {
        List<OrganizationResult> lstOrganizationResult = new List<OrganizationResult>();

        Dictionary<int, List<Organization>> dicLevelData = new Dictionary<int, List<Organization>>();

        foreach (Organization item in lstData)
        {
            int level = item.TreePath.Split('/').Length;

            if (dicLevelData.ContainsKey(level))
            {
                dicLevelData[level].Add(item);
            }
            else
            {
                dicLevelData.Add(level, new List<Organization>() { item });
            }
        }

        // 根据键值排序
        dicLevelData = dicLevelData.OrderBy(c => c.Key).ToDictionary(k => k.Key, k => k.Value);

        foreach (int key in dicLevelData.Keys)
        {
            foreach (Organization item in dicLevelData[key])
            {
                this.InsertOrganizationResult(key, item, lstOrganizationResult);
            }
        }

        return lstOrganizationResult;
    }

    /// <summary>
    /// 设置组织结构
    /// </summary>
    /// <param name="organizationLevel"></param>
    /// <param name="item"></param>
    /// <param name="lstOrganizaitonResult"></param>
    private void InsertOrganizationResult(int organizationLevel, Organization item, List<OrganizationResult> lstOrganizaitonResult)
    {
        // 如果属于根目录
        if (organizationLevel == 1)
        {
            lstOrganizaitonResult.Add(this.InitOrganizationResult(item));
            return;
        }

        // 如果不属于根目录
        string[] treePath = item.TreePath.Split('/');
        List<int> lstLevel = new List<int>();
        this.FindParentPath(lstOrganizaitonResult, lstLevel, treePath);
        List<OrganizationResult> lstChildrenTemp = lstOrganizaitonResult;
        foreach (int level in lstLevel)
        {
            if (lstOrganizaitonResult[level].GetChildNodesCount() == 0)
            {
                lstChildrenTemp = lstOrganizaitonResult[level].GetChildNodes();
            }
            else
            {
                lstChildrenTemp = lstChildrenTemp[level].GetChildNodes();
            }
        }

        lstChildrenTemp.Add(this.InitOrganizationResult(item));
    }

    /// <summary>
    /// 获取根目录父节点和父节点的位置
    /// </summary>
    /// <param name="lstOrganizaitonResult"></param>
    /// <param name="parentIndex"></param>
    /// <param name="childIndex"></param>
    /// <param name="treePath"></param>
    private void FindParentPath(List<OrganizationResult> lstOrganizaitonResult, List<int> lstLevel, string[] treePath)
    {
        for (int rootIndex = 0; rootIndex < lstOrganizaitonResult.Count; rootIndex++)
        {
            string levelKey = lstOrganizaitonResult[rootIndex].levelKey;

            // 找到第一任父节点继续往下找
            if (treePath[0] == levelKey)
            {
                lstLevel.Add(rootIndex);

                if (treePath.Length == 1)
                {
                    return;
                }

                // 如果不存在子节点，则直接添加
                if (lstOrganizaitonResult[rootIndex].GetChildNodesCount() == 0)
                {
                    return;
                }

                string[] tempLevel = new string[treePath.Length - 1];
                Array.Copy(treePath, 1, tempLevel, 0, tempLevel.Length);
                this.FindParentPath(lstOrganizaitonResult[rootIndex].GetChildNodes(), lstLevel, tempLevel);
                return;
            }
            else
            {
                continue;
            }
        }
    }

    /// <summary>
    /// 初始化一个组织结果数据
    /// </summary>
    /// <param name="key"></param>
    /// <param name="name"></param>
    /// <returns></returns>
    private OrganizationResult InitOrganizationResult(string key, string name, string parentKey)
    {
        return new OrganizationResult(key, name, parentKey);
    }

    /// <summary>
    /// 初始化一个组织结果数据
    /// </summary>
    /// <param name="key"></param>
    /// <param name="name"></param>
    /// <returns></returns>
    private OrganizationResult InitOrganizationResult(Organization organ)
    {
        string levelKey = null;
        string[] tempArr = organ.TreePath.Split('/');

        // 设置自己属于哪一个节点
        if (tempArr.Length == 1)
        {
            levelKey = tempArr[0];
        }
        else
        {
            levelKey = tempArr[tempArr.Length - 1];
        }

        return new OrganizationResult(organ.OrganKey, organ.OrganName, levelKey);
    }

    /// <summary>
    /// 初始化数据信息
    /// </summary>
    private void SetOrganziationData()
    {
        if (lstData == null)
        {
            lstData = new List<Organization>();
        }

        lstData.AddRange(
            new Organization[]{

                    new Organization("001","年级一","00001"),

                    // 班级一的学生信息(年级一)
                    new Organization("002","班级一","00001/10001"),
                    new Organization("003","学生A","00001/10001/11001"),
                    new Organization("004","学生B","00001/10001/11002"), 
                   
                    // 班级二的学生信息(年级一)
                    new Organization("005","班级二","00001/10002"),
                    new Organization("006","学生C", "00001/10002/12001"),

                    new Organization("007","年级二","00002"),

                    // 班级一的学生信息(年级二)
                    new Organization("008","班级一","00002/20001"),
                    new Organization("009","学生D","00002/20001/12001"),
                    new Organization("010","学生E","00002/20001/12002"),
                    
                    // 班级二的学生信息(年级二)
                    new Organization("011","班级二","00002/20002"),
                    new Organization("012","学生F","00002/20002/20001")
                }
        );
    }
    #endregion 组织架构的分析

    #region 生成JSON对象

    /// <summary>
    /// 生成JSON对象
    /// </summary>
    /// <param name="lstResult"></param>
    /// <returns></returns>
    private string CreateJson(List<OrganizationResult> lstResult)
    {
        StringBuilder strBuild = new StringBuilder("[");

        int index = 0;

        foreach (OrganizationResult item in lstResult)
        {
            if (index == 0)
            {
                strBuild.Append(this.CreateElement(item));
                strBuild.Append("\r\n");
            }
            else {
                strBuild.Append(","+this.CreateElement(item));
                strBuild.AppendLine("\r\n");
            }
            index++;
           
        }
        strBuild.AppendLine("]");
        return strBuild.ToString();
    }

    /// <summary>
    /// 创建一个对象
    /// </summary>
    /// <param name="item"></param>
    /// <returns></returns>
    private string CreateElement(OrganizationResult item)
    {
        StringBuilder strBuild = new StringBuilder("");

        if (item.GetChildNodesCount() != 0)
        {
            strBuild.AppendLine("{\"id\":" + "\"" + item.Key + "\",");
            strBuild.AppendLine("\"text\":" + "\"" + item.Name + "\",");
            strBuild.AppendLine("\"children\":[");
            bool isFirst = true;

            foreach (OrganizationResult element in item.GetChildNodes())
            {
                if (isFirst)
                {
                    strBuild.Append(this.CreateElement(element));
                 
                    isFirst = false;
                }
                else
                {
                    strBuild.AppendLine("," + this.CreateElement(element));
                }
            }

            strBuild.AppendLine("]}");
        }
        else
        {
            strBuild.AppendLine("{\"text\":" + "\"" + item.Name + "\"}");

            return strBuild.ToString();
        }

        return strBuild.ToString();
    }
    #endregion

    #region 创建JSON文件
    /// <summary>
    /// 创建JSON文件 
    /// </summary>
    /// <param name="fileData"></param>
    private void CreateJsonFile(String fileData)
    {
        string filePath = System.AppDomain.CurrentDomain.BaseDirectory + "data/tree_data.json";

        if (File.Exists(filePath))
        {
            File.Delete(filePath);
        }

        using (StreamWriter sw = new StreamWriter(new FileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.Write), System.Text.Encoding.UTF8))
        {
            sw.WriteLine(fileData);
        }
    }
    #endregion
}

/// <summary>
/// 组织数据
/// </summary>
public class Organization
{
    public string OrganKey { get; set; }

    public string OrganName { get; set; }

    public string TreePath { get; set; }

    public Organization(string organKey, string organName, string treePath)
    {
        this.OrganKey = organKey;
        this.OrganName = organName;
        this.TreePath = treePath;
    }
}