用递归形成树结构数据

定义一个树形实体 

        public class orgTrees
        {
            public orgTrees()
            {
                this.Children = new List<orgTrees>();
            }
            public int Id { get; set; }
            public int FatherId { get; set; }
            public string Name { get; set; }
            public int Lever { get; set; }
            public bool HasChildren { get; set; }
            public string OrgCode;
            public int OrgType;
            public List<orgTrees> Children { get; set; }
        }

开始递归方法

        /// <summary>
        /// 获取组织层级树
        /// </summary>
        /// <returns></returns>
        public AjaxResponse<orgTrees> GetOrgTrees()
        {
            var list = new List<orgTrees>();
            var orgLayerList = _organizeProxy.ListOrgInfoForManage();
            
            var dic = new Dictionary<int, orgTrees>(orgLayerList.Count);
            foreach (var item in orgLayerList)
            {
                dic.Add(item.Info.Id, new orgTrees
                {
                    Id = item.Info.Id,
                    FatherId = item.Info.FatherId,
                    Name = item.Info.Name.GetValueByLanId(WorkContext.WorkingLanguage.Id),
                    Lever = item.Layer,
                    OrgCode = item.Info.OrgCode,
                    OrgType = item.Info.OrgType,
                });
            }

            //根节点
            var rootNode = orgLayerList.Where(x => x.Info.FatherId.Equals(-1)).First();
            var model = new orgTrees();
            model.Id = rootNode.Info.Id;
            model.FatherId = rootNode.Info.FatherId;
            model.Name = rootNode.Info.Name.GetValueByLanId(WorkContext.WorkingLanguage.Id);
            model.Lever = rootNode.Layer;
            model.OrgCode = rootNode.Info.OrgCode;
            model.OrgType = rootNode.Info.OrgType;
            model.HasChildren = rootNode.HasChildren;
            CreatTree(model.Id, model, orgLayerList);
            return new AjaxResponse<orgTrees>(model);
        }
        //生成树的方法
        public void CreatTree(int parentId, orgTrees tree, LayerList<OrganizeInfo> laerList)
        {
            //获取子节点
            var childrenNode = laerList.ToList().FindAll(x => x.Info.FatherId == Convert.ToInt32(parentId));
            //如果没有字节点了，那就返回空
            if (childrenNode.Count == 0) return;
            List<orgTrees> nodeTrees = new List<orgTrees>();
            for (int i = 0; i < childrenNode.Count; i++)
            {
                orgTrees node = new orgTrees();
                node.Id = childrenNode[i].Info.Id;
                node.Name = childrenNode[i].Info.Name.GetValueByLanId(WorkContext.WorkingLanguage.Id);
                node.FatherId = childrenNode[i].Info.FatherId;
                node.Lever = childrenNode[i].Layer;
                node.OrgCode = childrenNode[i].Info.OrgCode;
                node.OrgType = childrenNode[i].Info.OrgType;
                node.HasChildren = childrenNode[i].HasChildren;
                //递归
                CreatTree(childrenNode[i].Info.Id, node, laerList);
                nodeTrees.Add(node);
            }
            tree.Children = nodeTrees; //由于对象是引用类型，因为可以改变参数的值
        }

说下思路就是 先把根节点找出来，然后寻找根节点的子节点 然后递归循环子节点，寻找子节点的子节点

最后生成的是就是