2021-09-09 C# 任意类型任意多个子列表对象转换为标准树形对象【工具类】

最新推荐文章于 2024-05-07 17:30:43 发布
最新推荐文章于 2024-05-07 17:30:43 发布
阅读量264 收藏
点赞数 1
分类专栏： C# 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43373549/article/details/120207833
版权

用途

将任意层级的对象，例如下面这个

public class Dept {
  public Dept(string name) { this.name = name; }
  public string name;
  public List<Dept> child;
  public List<Team> team;
  public List<Person> person;
  public override string ToString() {
	return $"Dept({name})";
  }
}
public class Team {
  public Team(string name) { this.name = name; }
  public string name;
  public List<Team> child;
  public List<Person> person;
  public override string ToString() {
	return $"Team({name})";
  }
}
public class Person {
  public Person(string name) { this.name = name; }
  public string name;
  public override string ToString() {
	return $"Person({name})";
  }
}

转换为单一的树形对象，例如下面这个

public class Label {
  public Label(string text) { this.text = text; }
  public string text;
  public List<Label> child;
}

调用方法举例：

  var listDept = new List<Dept>();
  var dept = new Dept("AA部门") {
	child = new List<Dept>() {
	  new Dept("BB部门") {
		person=new List<Person>(){ new Person("赵"), new Person("钱"), new Person("孙") },
		child=new List<Dept>() {
		  new Dept("CC部门") {
			team=new List<Team>() {
			  new Team("开发") {
				child=new List<Team>() {
				  new Team("前端") {
					person=new List<Person>() { new Person("李"), new Person("周") }
				  },
				  new Team("后端") {
					person=new List<Person>() { new Person("吴"), new Person("郑") }
				  }
				},
				person=new List<Person>() { new Person("王") }
			  },
			  new Team("运维"),
			}
		  },
		  new Dept("DD部门")
		}
	  }
	}
  };
  listDept.Add(dept);
  List<Label> list = TreeNode<Label>.ConvertList(listDept,
	// 设置子列表
	t => t.child ?? (t.child = new List<Label>()),
	// 所有类型转换定义
	new Dictionary<Type, Func<object, TreeNode<Label>>>() {
	  { typeof(Dept), t=>new TreeNode<Label>(new Label(t.ToString())) },
	  { typeof(Team), t=>new TreeNode<Label>(new Label(t.ToString())) },
	  { typeof(Person), t=>new TreeNode<Label>(new Label(t.ToString())) },
	},
	// 所有类型子列表定义
	new Dictionary<Type, Func<object, IList[]>>() {
	  { typeof(Dept), t=>new IList[]{ ((Dept)t).child, ((Dept)t).person, ((Dept)t).team } },
	  { typeof(Team), t=>new IList[]{ ((Team)t).child, ((Team)t).person } },
	}
  );
  Console.WriteLine(list.toJSON());

输出结果：

[
  {
    "text": "Dept(AA部门)",
    "child": [
      {
        "text": "Dept(BB部门)",
        "child": [
          {
            "text": "Dept(CC部门)",
            "child": [
              {
                "text": "Team(开发)",
                "child": [
                  {
                    "text": "Team(前端)",
                    "child": [
                      {
                        "text": "Person(李)",
                        "child": null
                      },
                      {
                        "text": "Person(周)",
                        "child": null
                      }
                    ]
                  },
                  {
                    "text": "Team(后端)",
                    "child": [
                      {
                        "text": "Person(吴)",
                        "child": null
                      },
                      {
                        "text": "Person(郑)",
                        "child": null
                      }
                    ]
                  },
                  {
                    "text": "Person(王)",
                    "child": null
                  }
                ]
              },
              {
                "text": "Team(运维)",
                "child": null
              }
            ]
          },
          {
            "text": "Dept(DD部门)",
            "child": null
          },
          {
            "text": "Person(赵)",
            "child": null
          },
          {
            "text": "Person(钱)",
            "child": null
          },
          {
            "text": "Person(孙)",
            "child": null
          }
        ]
      }
    ]
  }
]

工具类：

using System;
using System.Collections;
using System.Collections.Generic;

namespace Ccino.Lib {

  public class TreeNode<T> {
    public TreeNode(T item) {
      this.item = item;
    }
    /// <summary>
    /// 挂载对象
    /// </summary>
    public T item;
    /// <summary>
    /// 原始对象
    /// </summary>
    [Newtonsoft.Json.JsonIgnore]
    public object sourceItem;
    /// <summary>
    /// 子列表
    /// </summary>
    public List<TreeNode<T>> children;
    /// <summary>
    /// 父对象
    /// </summary>
    [Newtonsoft.Json.JsonIgnore]
    public TreeNode<T> parent;

    /// <summary>
    /// 将TreeNode列表转换为目标类型列表
    /// </summary>
    /// <typeparam name="E">目标类型</typeparam>
    /// <param name="listNode">TreeNode列表</param>
    /// <param name="convertAction">转换方法</param>
    /// <param name="getChildList">子列表获取/处理</param>
    public static List<E> ConvertTo<E>(List<TreeNode<T>> listNode, Func<TreeNode<T>, E> convertAction, Func<E, List<E>> getChildList) {
      List<E> list = new List<E>();
      foreach (var node in listNode) {
        E e = convertAction(node);
        // 处理当前列表
        if (e != null) {
          list.Add(e);
        }
        // 处理子列表
        if (node.children != null) {
          var childList = getChildList(e);
          childList.AddRange(ConvertTo<E>(node.children, convertAction, getChildList));
        }
      }
      return list;
    }

    /// <summary>
    /// 转换树形对象
    /// </summary>
    /// <param name="sourceTree">原始树列表</param>
    /// <param name="getSetChildList">原始数对象子列表获取/设置</param>
    /// <param name="convertActionDict">类型转换字典，定义可被转换为TreeNode的类型</param>
    /// <param name="getChildListDict">子列表获取字典， 定义需要处理的类型子列表</param>
    public static List<T> ConvertList(IList sourceTree, Func<T, List<T>> getSetChildList,
      Dictionary<Type, Func<object, TreeNode<T>>> convertActionDict,
      Dictionary<Type, Func<object, IList[]>> getChildListDict) {
      var nodeList = ConvertTreeNode(sourceTree, convertActionDict, getChildListDict);
      return ConvertTo<T>(nodeList, node => node.item, getSetChildList);
    }

    /// <summary>
    /// 转换树形对象
    /// </summary>
    /// <param name="sourceTree">原始树列表</param>
    /// <param name="convertActionDict">类型转换字典，定义可被转换为TreeNode的类型</param>
    /// <param name="getChildListDict">子列表获取字典， 定义需要处理的类型子列表</param>
    public static List<TreeNode<T>> ConvertTreeNode(IList sourceTree,
    Dictionary<Type, Func<object, TreeNode<T>>> convertActionDict,
    Dictionary<Type, Func<object, IList[]>> getChildListDict) {
      List<TreeNode<T>> resultList = new List<TreeNode<T>>();

      Func<object, TreeNode<T>> convertTAction = null;
      #region 获得转换原始对象方法
      if (sourceTree.Count > 0) {
        var type = sourceTree[0].GetType();

        if (!convertActionDict.TryGetValue(type, out convertTAction)) {
          Console.WriteLine(type + " " + convertTAction);
          return resultList;
        }
      } else {
        return resultList;
      }
      #endregion

      for (int i = 0, len = sourceTree.Count; i < len; ++i) {
        object sourceItem = sourceTree[i];
        //1. 处理原始对象转换
        TreeNode<T> currentNode = null;
        currentNode = convertTAction(sourceItem);
        if (currentNode == null) continue; //如果无法转换node，直接跳过
        currentNode.sourceItem = sourceItem; //记录原始对象
        resultList.Add(currentNode);
        //2. 处理所有子列表转换
        Type sourceType = sourceItem.GetType();
        foreach (var kv in getChildListDict) {
          Type type = kv.Key;
          if (sourceType != type) continue;
          Func<object, IList[]> getListAction = kv.Value;
          IList[] lists = getListAction(sourceItem);
          if (lists != null && lists.Length > 0) {
            foreach (var list in lists) {
              if (list != null && list.Count > 0) {
                var listNode = ConvertTreeNode(list, convertActionDict, getChildListDict);
                if (listNode.Count > 0) {
                  if (currentNode.children == null) {
                    currentNode.children = new List<TreeNode<T>>();
                  }
                  listNode.ForEach(n => {
                    n.parent = currentNode;
                    currentNode.children.Add(n);
                  });
                }
              }
            }
          }
        }
      }
      return resultList;
    }

  }
}
西瓜很快
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Thinkergod#PeiQi-WIKI-POC#若依管理系统 后台任意文件读取 CNVD-2021-019312
07-25
若依(RuoYi)管理系统 后台任意文件读取漏洞描述若依管理系统是基于SpringBoot的权限管理系统,登录后台后可以读取服务器上的任意文件漏洞影响app="
go 类型断言_聊聊golang的类型断言
weixin_39809140的博客
11-29 272
序本文主要研究一下golang的类型断言类型断言x.(T)断言x不为nil且x为T类型如果T不是接口类型，则该断言x为T类型如果T类接口类型，则该断言x实现了T接口实例1funcmain(){varxinterface{}=7i:=x.(int)fmt.Println(reflect.TypeOf(i))j:=x.(int32)fmt.P...
c# 泛型类
limonero
12-07 1163
1、创建泛型类 使用<T> 来表示泛型类类型。 不能把null赋值为泛型类型。 泛型赋值：使用default关键字。default会把引用类型使用null赋值，把值类型使用0赋值 Public class Document<T> { public T getDoc() { T doc = default; //其他代码 return doc; } } 2、泛型范围，即泛型的使用范围
实体类生成树结构
YP_luck的博客
11-24 237
生成树结构 实体类 @Accessors(chain = true) @Data public class Menu { private Integer id; // 主键 private String name; // 菜单名 private Integer parentId; // 父菜单id private Menu parent; // 父菜单 private Collection<Menu> childList; } 工具类 public
C# 根据typename字符串，创建任意类型的对象（含泛型）
文盲的专栏
06-01 6969
在c#中，反射时个很好用的东西，可以通过反射动态创建一个实例，且实例类型不唯一 一个很简单的例子，来了解下反射可以做什么 Type t = typeof(Form); dynamic frm = t.Assembly.CreateInstance(t.FullName); // 以上内容完全等同于 dynamic frm = new Form(); Type t = typeof(List<string>); dynamic lst = t.Assembly.CreateInstanc
在变量声明中指定类型
weixin_57764814的博客
05-18 259
1.内置类型 C#提供了一组标准的内置对象来表示整数，浮点数，布尔表达式，文本字符，十进制值和其他数据类型。还有内置的 string 和 object 类型。 2.自定义类型 可以使用 struct 、 class 、 interface 、 enum 和 record 构造来创建自己的自定义类型。 NET 类库本身是一组自定义类型，以供你在自己的应用程序中使用。 默认情况下，类库中最常用的类型在任何 C# 程序中均可用。 对于其他类型，只有在显式添加对定义这些类型的程序集的项目引用时才可用。 编译器
C# 中Object的方法含义以及使用（详）
猪猪的博客
02-13 3369
C# 中Object的方法含义以及使用（详）
2021-2022收藏资料面向对象程序设计(C#)第4章.doc
09-26
2021年09月16日
C# DataTable 转换为 实体类对象实例
09-08
如果你的实体类与数据库表是完全一致的。上代码：
C#对象转换类C#对象转换类C#对象转换类
06-27
C#对象转换类C#对象转换类C#对象转换类C#对象转换类C#对象转换类
c# 对象类型转换，包括时间转换、string 和int转换等
02-23
c# 对象类型转换，包括时间转换、string 和int转换等
C#之数据类型
博客
02-08 337
c#有15个预定义类型，其中13个是值类型，两个是引用类型(string 和 object)       1、整型      2、浮点类型       float数据类型用于较小的浮点数，因为它要求的精度较低。     double数据类型比float数据类型大，提供的精度也大一倍(15位)。     如果在代码中没有对某个非整数值(如12.
C#变量的类型
qq_37956302的博客
04-08 462
常使用的类型 char用来存储单个字符 int可以存储-2147483648 ~ 2147483647之间的任何整数（−231-2^{31}−231 ~2312^{31}231) string可以存储任意长度的文本（包括空串“”） bool是个布尔值，包括true和false double可以存储±5.0×10−324\pm5.0×10^{-324}±5.0×10−324 ~ ±1.7×10308\pm1.7×10^{308}±1.7×10308之间的任意小数（16位有效数字） 2.更多表示整数的类型 .
c# 任意类型排序算法
m0_55540902的博客
12-01 187
任意类型排序算法
C#转换js上需要的树形数据
zhang123csdn的博客
09-14 318
C#转换js上需要的树形数据 2 C#后台获取的数据是多条的，并且有parentID的数据。
c#语言入门类型和成员学习通http://www.bdgxy.com/
菜鸟教程
05-12 308
文章来源： 学习通http://www.bdgxy.com/普学网http://www.boxinghulanban.cn/智学网http://www.jaxp.net/表格制作excel教程http://www.tpyjn.cn/学习通http://www.tsgmyy.cn/ 目录一、类和对象1、类型参数 2、基类 二、结构 三、接口 四、枚举 五、可为 null 的类型 六、元组 前言: 作为面向对象的语言，C# 支持封装、继承和多态性这些概念。 类可能会直接继承一个父类，并且可以实现任意数量的接
【Halcon 内存泄漏记录 - C#】
最新发布
ruotianxia的博客
05-07 351
【代码】【Halcon 内存泄漏记录 - C#】
C# List对象转换为Array对象
06-07
可以使用List的ToArray()方法将C# List对象转换为Array对象。例如： ```csharp List<int> myList = new List() { 1, 2, 3, 4, 5 }; int[] myArray = myList.ToArray(); ``` 这样就可以将myList转换为一个整数类型...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值