Question

我有一个包含

的嵌套列表

public class Person
{
    public Person(string name)
    {
        this.Name = name;
    }

    public string Name { get; set; }

    public List<Person> Childs { get; set; }
}

该列表的用法类似于：

var Persons = new List<Person>();
Persons.Add(new Person("Eric"));
Persons[0].Childs = new List<Person>();
Persons[0].Childs.Add(new Person("Tom"));
Persons[0].Childs.Add(new Person("John"));
Persons[0].Childs[0].Childs = new List<Person>();
Persons[0].Childs[0].Childs.Add(new Person("Bill"));
Persons.Add(new Person("John");

现在我有这个课程：

public class Human
{
    public string Name { get; set; }

    public int Age { get; set; }

    public List<Human> SubHuman { get; set; }
}

可以说“人员”列表已创建。现在如何在“人员”列表中创建新列表Humans（在列表中重复），而每个人员的名称都是相应人员的名称？它也应该像人类一样嵌套，所有人类的年龄都应为12岁。

Answer 1

private static List<Human> Convert(List<Person> persons)
{
    List<Human> humans = new List<Human>();
    foreach (Person p in persons)
    {
        Human newHuman = new Human(p.Name, 12);
        if (p.Childs != null)
        {
            newHuman.SubHuman = convert(p.Childs);
        }
        humans.Add(newHuman);
    }
    return humans;
}

我还在Human类中添加了一个构造函数。

class Human
{
    public string Name { get; set; }

    public int Age { get; set; }

    public List<Human> SubHuman { get; set; }

    public Human(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

在您的示例中像这样使用它：

var Humans = Convert(Persons);

Answer 2

如果我正确理解它，“人”和“人”只有共同的属性……我只看到一种“手动”方式将一个类实例映射到另一个类实例。

期望SubHuman，分别。孩子们可能很深，我选择了递归解决方案。

这里是一个例子：

    static Human Convert(Person p)
    {
        var result = new Human() { Name = p.Name, Age = 12 };
        if (p.Childs?.Any() == true)
        {
            result.SubHuman = new List<Human>();
            p.Childs.ForEach(x => result.SubHuman.Add(Convert(x))); //Recursion here
        }
        return result;
    }

这可以通过以下方式调用：

 List<Human> humans = Persons.Select(x => Convert(x)).ToList();

编辑：我认为这不是一种可持续的方法。根据这样做的目的，我建议将公共接口设为继承或继承。

Answer 3

您正在将一个实体映射到另一个实体，并且由于那里有一个树结构/嵌套（可能是无限的），因此可以使用递归，但要谨慎行事-真正无限的嵌套会导致堆栈溢出

给出此示例列表：

List<Person> people = new List<Person> {
  new Person("Tom")
  {
    Childs = new List<Person> {
        new Person("Maria"),
        new Person("Jonathan") {
            Childs = new List<Person> {
                new Person("Frank")
            }
        }
    }
  },
  new Person("Ila")
};

这个本地函数：

Human Extract(Person guy) 
{
    return new Human { Name = guy.Name, Age = 12, SubHuman = guy.Childs?.Select(Extract).ToList() ?? new List<Human>() };
}

然后您可以使用单个表达式映射原始列表：

List<Human> humans = people.Select(Extract).ToList();

如何将值从嵌套列表复制到新列表

3 个答案: