Question

我有一个模型，它有一个对象列表，它有一个对象列表，它有一个对象列表等等。我想要做的是以一种很好的方式计算所有子对象。

我设置了以下示例：

这是我的模特：

public class Model
{
    public List<GrandParent> GrandParents { get; set; }
}

这些是我的目标：

public class GrandParent
{
    public string Name { get; set; }
    public List<Parent> Parents { get; set; }
}

public class Parent
{
    public string Name { get; set; }
    public List<Child> Children { get; set; }
}

public class Child
{
    public string Name { get; set; }
    public List<Friend> Friends { get; set; }
}

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

以下是我在控制台应用中的设置：

static void Main(string[] args)
    {
        var friendOne = new Friend { Name = "Friend 1" };
        var childOne = new Child { Name = "Child 1", Friends = new List<Friend>() };
        var childTwo = new Child { Name = "Child 2", Friends = new List<Friend> { friendOne } };
        var parentOne = new Parent { Name = "Parent 1", Children = new List<Child> { childOne, childTwo } };
        var grandParentOne = new GrandParent { Name = "GrandParent 1", Parents = new List<Parent> { parentOne } };

        var model = new Model { GrandParents = new List<GrandParent> { grandParentOne } };

        var count = model.GrandParents.Count +
            model.GrandParents
                .Sum(gp => gp.Parents.Count + gp.Parents
                .Sum(p => p.Children.Count + p.Children
                .Sum(c => c.Friends.Count)));

        Console.WriteLine(count);
        Console.ReadLine();
    }

所以我有5个对象（1个朋友，2个孩子，1个父母和1个祖父母），我的计数变量给了我。但是我不喜欢我在linq查询中这样做的方式，有更好/更清晰的方法吗？

Answer 1

正如评论中提到的，一种方法是对树中的所有节点使用相同的对象，并且可以写一些递归的东西。

另一种方式，如果你想保留这些对象，那就是让它们都实现一个接口，它只知道如何计算后代。

public interface IHasDescendents
{
   int CountOfDescendents();
}

通过为所有类实现该接口，您的代码将只是

var count = model.GrandParents.Sum(gp => 1 + gp.CountOfDescendents());

我怀疑你可以实施细节，但如果不只是评论，我会告诉你如何。

如何计算Linq

1 个答案: